| 1 | # Reply server mig-output massager |
| 2 | # |
| 3 | # Copyright (C) 1995-2019 Free Software Foundation, Inc. |
| 4 | # |
| 5 | # Written by Miles Bader <miles@gnu.ai.mit.edu> |
| 6 | # |
| 7 | # This program is free software; you can redistribute it and/or |
| 8 | # modify it under the terms of the GNU General Public License as |
| 9 | # published by the Free Software Foundation; either version 3, or (at |
| 10 | # your option) any later version. |
| 11 | # |
| 12 | # This program is distributed in the hope that it will be useful, but |
| 13 | # WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | # General Public License for more details. |
| 16 | # |
| 17 | # You should have received a copy of the GNU General Public License |
| 18 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 19 | # |
| 20 | # This awk script hacks the output of mig-generated reply server code |
| 21 | # so that it allows replies with just the error-code in them (as this is |
| 22 | # how mig returns errors). |
| 23 | # |
| 24 | # It is highly, highly, dependent on the exact format of mig output. Ick. |
| 25 | # |
| 26 | |
| 27 | BEGIN { parse_phase = 0; } |
| 28 | |
| 29 | /^}/ { parse_phase = 0; } |
| 30 | |
| 31 | parse_phase == 0 && /^mig_internal void _X[a-zA-Z0-9_]*_reply/ { |
| 32 | # The start of a mig server routine. Reset everything. Note that we only |
| 33 | # mess with rpcs that have the suffix `_reply'. |
| 34 | num_args = 0; |
| 35 | num_checks = 0; |
| 36 | parse_phase = 1; |
| 37 | print; next; |
| 38 | } |
| 39 | |
| 40 | parse_phase == 1 && /^[\t ]*typedef struct/ { |
| 41 | # The first structure in the server routine should describe the arguments |
| 42 | parse_phase = 2; |
| 43 | print; next; |
| 44 | } |
| 45 | |
| 46 | parse_phase == 2 { |
| 47 | # The message header field in the args structure, which skip. |
| 48 | parse_phase = 3; |
| 49 | print; next; |
| 50 | } |
| 51 | |
| 52 | parse_phase == 3 && /} Request/ { |
| 53 | # The args structure is over. |
| 54 | if (num_args > 1) |
| 55 | parse_phase = 5; |
| 56 | else |
| 57 | # There's no extra args that could screw up the normal mechanism for |
| 58 | # error returns, so we don't have to insert any new code. |
| 59 | parse_phase = 0; |
| 60 | print; next; |
| 61 | } |
| 62 | |
| 63 | parse_phase == 3 && num_args == 0 { |
| 64 | # The type field for an argument. |
| 65 | # This won't be accurate in case of unions being used in the Request struct, |
| 66 | # but that doesn't matter, as we'll only be looking at arg_type_code_name[0], |
| 67 | # which will not be a union type. |
| 68 | arg_type_code_name[num_args] = $2; |
| 69 | sub (/;$/, "", arg_type_code_name[num_args]) # Get rid of the semi-colon |
| 70 | parse_phase = 4; |
| 71 | print; next; |
| 72 | } |
| 73 | |
| 74 | parse_phase == 3 && num_args == 1 { |
| 75 | # We've got more than one argument (but we don't care what it is). |
| 76 | num_args++; |
| 77 | print; next; |
| 78 | } |
| 79 | |
| 80 | parse_phase == 3 { |
| 81 | # We've know everything we need; now just wait for the end of the Request |
| 82 | # struct. |
| 83 | print; next; |
| 84 | } |
| 85 | |
| 86 | parse_phase == 4 { |
| 87 | # The value field for an argument. |
| 88 | # This won't be accurate in case of unions being used in the Request struct, |
| 89 | # but that doesn't matter, as we'll only be looking at arg_name[0], which |
| 90 | # will not be a union type. |
| 91 | arg_name[num_args] = $2; |
| 92 | sub (/;$/, "", arg_name[num_args]) # Get rid of the semi-colon |
| 93 | num_args++; |
| 94 | parse_phase = 3; |
| 95 | print; next; |
| 96 | } |
| 97 | |
| 98 | parse_phase == 5 && /^[ \t]*(auto |static )?const mach_msg_type_t/ { |
| 99 | # The type check structure for an argument. |
| 100 | arg_check_name[num_checks] = $(NF - 2); |
| 101 | num_checks++; |
| 102 | print; next; |
| 103 | } |
| 104 | |
| 105 | parse_phase == 5 && /^[ \t]*mig_external kern_return_t/ { |
| 106 | # The declaration of the user server function for this rpc. |
| 107 | user_function_name = $3; |
| 108 | print; next; |
| 109 | } |
| 110 | |
| 111 | parse_phase == 5 && /^#if[ \t]TypeCheck/ { |
| 112 | # Keep going if we have not yet collected the type check structures. |
| 113 | if (num_checks == 0) |
| 114 | { |
| 115 | print; next; |
| 116 | } |
| 117 | |
| 118 | # The first args type checking statement; we need to insert our chunk of |
| 119 | # code that bypasses all the type checks if this is an error return, after |
| 120 | # which we're done until we get to the next function. Handily, the size |
| 121 | # of mig's Reply structure is also the size of the alternate Request |
| 122 | # structure that we want to check for. |
| 123 | print "\tif (In0P->Head.msgh_size == sizeof (Reply)"; |
| 124 | print "\t && ! (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX)"; |
| 125 | print "\t && ! BAD_TYPECHECK(&In0P->" arg_type_code_name[0] ", &" arg_check_name[0] ")"; |
| 126 | print "\t && In0P->" arg_name[0] " != 0)"; |
| 127 | print "\t /* Error return, only the error code argument is passed. */"; |
| 128 | print "\t {"; |
| 129 | # Force the function user_function_name into a type that only takes the first |
| 130 | # two arguments. |
| 131 | # This is possibly bogus, but easier than supplying bogus values for all |
| 132 | # the other args (we can't just pass 0 for them, as they might not be scalar). |
| 133 | print "\t OutP->RetCode = (*(kern_return_t (*)(mach_port_t, kern_return_t)) " user_function_name ") (In0P->Head.msgh_request_port, In0P->" arg_name[0] ");"; |
| 134 | print "\t return;"; |
| 135 | print "\t }"; |
| 136 | print ""; |
| 137 | parse_phase = 0; |
| 138 | print; next; |
| 139 | } |
| 140 | |
| 141 | { print; } |