macosx/RPC/JackRPCClientUser.c

   1 /*
   2  * IDENTIFICATION:
   3  * stub generated Fri Oct 23 10:35:08 2009
   4  * with a MiG generated Mon May 18 09:59:33 PDT 2009 by root@sulitlana.apple.com
   5  * OPTIONS:
   6  */
   7 #define __MIG_check__Reply__JackRPCClient_subsystem__ 1
   8 #define __NDR_convert__Reply__JackRPCClient_subsystem__ 1
   9 #define __NDR_convert__mig_reply_error_subsystem__ 1
  10
  11 #include "JackRPCClient.h"
  12
  13
  14 #ifndef mig_internal
  15 #define mig_internal    static __inline__
  16 #endif  /* mig_internal */
  17
  18 #ifndef mig_external
  19 #define mig_external
  20 #endif  /* mig_external */
  21
  22 #if     !defined(__MigTypeCheck) && defined(TypeCheck)
  23 #define __MigTypeCheck          TypeCheck       /* Legacy setting */
  24 #endif  /* !defined(__MigTypeCheck) */
  25
  26 #if     !defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
  27 #define __MigKernelSpecificCode _MIG_KERNEL_SPECIFIC_CODE_      /* Legacy setting */
  28 #endif  /* !defined(__MigKernelSpecificCode) */
  29
  30 #ifndef LimitCheck
  31 #define LimitCheck 0
  32 #endif  /* LimitCheck */
  33
  34 #ifndef min
  35 #define min(a,b)  ( ((a) < (b))? (a): (b) )
  36 #endif  /* min */
  37
  38 #if !defined(_WALIGN_)
  39 #define _WALIGN_(x) (((x) + 3) & ~3)
  40 #endif /* !defined(_WALIGN_) */
  41
  42 #if !defined(_WALIGNSZ_)
  43 #define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
  44 #endif /* !defined(_WALIGNSZ_) */
  45
  46 #ifndef UseStaticTemplates
  47 #define UseStaticTemplates      0
  48 #endif  /* UseStaticTemplates */
  49
  50 #ifndef __MachMsgErrorWithTimeout
  51 #define __MachMsgErrorWithTimeout(_R_) { \
  52         switch (_R_) { \
  53         case MACH_SEND_INVALID_DATA: \
  54         case MACH_SEND_INVALID_DEST: \
  55         case MACH_SEND_INVALID_HEADER: \
  56                 mig_put_reply_port(InP->Head.msgh_reply_port); \
  57                 break; \
  58         case MACH_SEND_TIMED_OUT: \
  59         case MACH_RCV_TIMED_OUT: \
  60         default: \
  61                 mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
  62         } \
  63 }
  64 #endif  /* __MachMsgErrorWithTimeout */
  65
  66 #ifndef __MachMsgErrorWithoutTimeout
  67 #define __MachMsgErrorWithoutTimeout(_R_) { \
  68         switch (_R_) { \
  69         case MACH_SEND_INVALID_DATA: \
  70         case MACH_SEND_INVALID_DEST: \
  71         case MACH_SEND_INVALID_HEADER: \
  72                 mig_put_reply_port(InP->Head.msgh_reply_port); \
  73                 break; \
  74         default: \
  75                 mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
  76         } \
  77 }
  78 #endif  /* __MachMsgErrorWithoutTimeout */
  79
  80 #ifndef __DeclareSendRpc
  81 #define __DeclareSendRpc(_NUM_, _NAME_)
  82 #endif  /* __DeclareSendRpc */
  83
  84 #ifndef __BeforeSendRpc
  85 #define __BeforeSendRpc(_NUM_, _NAME_)
  86 #endif  /* __BeforeSendRpc */
  87
  88 #ifndef __AfterSendRpc
  89 #define __AfterSendRpc(_NUM_, _NAME_)
  90 #endif  /* __AfterSendRpc */
  91
  92 #ifndef __DeclareSendSimple
  93 #define __DeclareSendSimple(_NUM_, _NAME_)
  94 #endif  /* __DeclareSendSimple */
  95
  96 #ifndef __BeforeSendSimple
  97 #define __BeforeSendSimple(_NUM_, _NAME_)
  98 #endif  /* __BeforeSendSimple */
  99
 100 #ifndef __AfterSendSimple
 101 #define __AfterSendSimple(_NUM_, _NAME_)
 102 #endif  /* __AfterSendSimple */
 103
 104 #define msgh_request_port       msgh_remote_port
 105 #define msgh_reply_port         msgh_local_port
 106
 107
 108
 109 #if ( __MigTypeCheck || __NDR_convert__ )
 110 #if __MIG_check__Reply__JackRPCClient_subsystem__
 111 #if !defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined)
 112 #define __MIG_check__Reply__rpc_jack_client_sync_notify_t__defined
 113 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined
 114 #if     defined(__NDR_convert__int_rep__JackRPCClient__kern_return_t__defined)
 115 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined
 116 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode(a, f) \
 117         __NDR_convert__int_rep__JackRPCClient__kern_return_t((kern_return_t *)(a), f)
 118 #elif   defined(__NDR_convert__int_rep__kern_return_t__defined)
 119 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined
 120 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode(a, f) \
 121         __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
 122 #endif /* defined(__NDR_convert__*__defined) */
 123 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined */
 124
 125
 126 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 127 #if     defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
 128 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 129 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 130         __NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
 131 #elif   defined(__NDR_convert__int_rep__int__defined)
 132 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 133 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 134         __NDR_convert__int_rep__int((int *)(a), f)
 135 #elif   defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
 136 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 137 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 138         __NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
 139 #elif   defined(__NDR_convert__int_rep__int32_t__defined)
 140 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 141 #define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 142         __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
 143 #endif /* defined(__NDR_convert__*__defined) */
 144 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
 145
 146
 147
 148 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 149 #if     defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
 150 #define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 151 #define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 152         __NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
 153 #elif   defined(__NDR_convert__char_rep__int__defined)
 154 #define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 155 #define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 156         __NDR_convert__char_rep__int((int *)(a), f)
 157 #elif   defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
 158 #define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 159 #define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 160         __NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
 161 #elif   defined(__NDR_convert__char_rep__int32_t__defined)
 162 #define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 163 #define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 164         __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
 165 #endif /* defined(__NDR_convert__*__defined) */
 166 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
 167
 168
 169
 170 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 171 #if     defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
 172 #define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 173 #define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 174         __NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
 175 #elif   defined(__NDR_convert__float_rep__int__defined)
 176 #define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 177 #define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 178         __NDR_convert__float_rep__int((int *)(a), f)
 179 #elif   defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
 180 #define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 181 #define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 182         __NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
 183 #elif   defined(__NDR_convert__float_rep__int32_t__defined)
 184 #define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
 185 #define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
 186         __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
 187 #endif /* defined(__NDR_convert__*__defined) */
 188 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
 189
 190
 191
 192 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_sync_notify_t(__Reply__rpc_jack_client_sync_notify_t *Out0P)
 193 {
 194
 195         typedef __Reply__rpc_jack_client_sync_notify_t __Reply;
 196 #if     __MigTypeCheck
 197         unsigned int msgh_size;
 198 #endif  /* __MigTypeCheck */
 199         if (Out0P->Head.msgh_id != 1100) {
 200             if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 201                 { return MIG_SERVER_DIED; }
 202             else
 203                 { return MIG_REPLY_MISMATCH; }
 204         }
 205
 206 #if     __MigTypeCheck
 207         msgh_size = Out0P->Head.msgh_size;
 208
 209         if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
 210             ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
 211              (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
 212               Out0P->RetCode == KERN_SUCCESS)))
 213                 { return MIG_TYPE_ERROR ; }
 214 #endif  /* __MigTypeCheck */
 215
 216         if (Out0P->RetCode != KERN_SUCCESS) {
 217 #ifdef  __NDR_convert__mig_reply_error_t__defined
 218                 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
 219 #endif  /* __NDR_convert__mig_reply_error_t__defined */
 220                 return ((mig_reply_error_t *)Out0P)->RetCode;
 221         }
 222
 223 #if     defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined) || \
 224         defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
 225         if (Out0P->NDR.int_rep != NDR_record.int_rep) {
 226 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined)
 227                 __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
 228 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined */
 229 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
 230                 __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(&Out0P->result, Out0P->NDR.int_rep);
 231 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
 232         }
 233 #endif  /* defined(__NDR_convert__int_rep...) */
 234
 235 #if     0 || \
 236         defined(__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
 237         if (Out0P->NDR.char_rep != NDR_record.char_rep) {
 238 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
 239                 __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(&Out0P->result, Out0P->NDR.char_rep);
 240 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
 241         }
 242 #endif  /* defined(__NDR_convert__char_rep...) */
 243
 244 #if     0 || \
 245         defined(__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
 246         if (Out0P->NDR.float_rep != NDR_record.float_rep) {
 247 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
 248                 __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(&Out0P->result, Out0P->NDR.float_rep);
 249 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
 250         }
 251 #endif  /* defined(__NDR_convert__float_rep...) */
 252
 253         return MACH_MSG_SUCCESS;
 254 }
 255 #endif /* !defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined) */
 256 #endif /* __MIG_check__Reply__JackRPCClient_subsystem__ */
 257 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
 258
 259
 260 /* Routine rpc_jack_client_sync_notify */
 261 mig_external kern_return_t rpc_jack_client_sync_notify
 262 (
 263         mach_port_t client_port,
 264         int refnum,
 265         client_name_t client_name,
 266         int notify,
 267         message_t message,
 268         int value1,
 269         int value2,
 270         int *result
 271 )
 272 {
 273
 274 #ifdef  __MigPackStructs
 275 #pragma pack(4)
 276 #endif
 277         typedef struct {
 278                 mach_msg_header_t Head;
 279                 NDR_record_t NDR;
 280                 int refnum;
 281                 client_name_t client_name;
 282                 int notify;
 283                 message_t message;
 284                 int value1;
 285                 int value2;
 286         } Request;
 287 #ifdef  __MigPackStructs
 288 #pragma pack()
 289 #endif
 290
 291 #ifdef  __MigPackStructs
 292 #pragma pack(4)
 293 #endif
 294         typedef struct {
 295                 mach_msg_header_t Head;
 296                 NDR_record_t NDR;
 297                 kern_return_t RetCode;
 298                 int result;
 299                 mach_msg_trailer_t trailer;
 300         } Reply;
 301 #ifdef  __MigPackStructs
 302 #pragma pack()
 303 #endif
 304
 305 #ifdef  __MigPackStructs
 306 #pragma pack(4)
 307 #endif
 308         typedef struct {
 309                 mach_msg_header_t Head;
 310                 NDR_record_t NDR;
 311                 kern_return_t RetCode;
 312                 int result;
 313         } __Reply;
 314 #ifdef  __MigPackStructs
 315 #pragma pack()
 316 #endif
 317         /*
 318          * typedef struct {
 319          *      mach_msg_header_t Head;
 320          *      NDR_record_t NDR;
 321          *      kern_return_t RetCode;
 322          * } mig_reply_error_t;
 323          */
 324
 325         union {
 326                 Request In;
 327                 Reply Out;
 328         } Mess;
 329
 330         Request *InP = &Mess.In;
 331         Reply *Out0P = &Mess.Out;
 332
 333         mach_msg_return_t msg_result;
 334
 335 #ifdef  __MIG_check__Reply__rpc_jack_client_sync_notify_t__defined
 336         kern_return_t check_result;
 337 #endif  /* __MIG_check__Reply__rpc_jack_client_sync_notify_t__defined */
 338
 339         __DeclareSendRpc(1000, "rpc_jack_client_sync_notify")
 340
 341         InP->NDR = NDR_record;
 342
 343         InP->refnum = refnum;
 344
 345         (void) mig_strncpy(InP->client_name, client_name, 64);
 346
 347         InP->notify = notify;
 348
 349         (void) mig_strncpy(InP->message, message, 256);
 350
 351         InP->value1 = value1;
 352
 353         InP->value2 = value2;
 354
 355         InP->Head.msgh_bits =
 356                 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
 357         /* msgh_size passed as argument */
 358         InP->Head.msgh_request_port = client_port;
 359         InP->Head.msgh_reply_port = mig_get_reply_port();
 360         InP->Head.msgh_id = 1000;
 361
 362         __BeforeSendRpc(1000, "rpc_jack_client_sync_notify")
 363         msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_SEND_TIMEOUT|MACH_RCV_TIMEOUT|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, 5000, MACH_PORT_NULL);
 364         __AfterSendRpc(1000, "rpc_jack_client_sync_notify")
 365
 366         if (msg_result == MACH_SEND_TIMED_OUT) {
 367         }
 368
 369         if (msg_result != MACH_MSG_SUCCESS) {
 370                 __MachMsgErrorWithTimeout(msg_result);
 371                 { return msg_result; }
 372         }
 373
 374
 375 #if     defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined)
 376         check_result = __MIG_check__Reply__rpc_jack_client_sync_notify_t((__Reply__rpc_jack_client_sync_notify_t *)Out0P);
 377         if (check_result != MACH_MSG_SUCCESS)
 378                 { return check_result; }
 379 #endif  /* defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined) */
 380
 381         *result = Out0P->result;
 382
 383         return KERN_SUCCESS;
 384 }
 385
 386 /* SimpleRoutine rpc_jack_client_async_notify */
 387 mig_external kern_return_t rpc_jack_client_async_notify
 388 (
 389         mach_port_t client_port,
 390         int refnum,
 391         client_name_t client_name,
 392         int notify,
 393         message_t message,
 394         int value1,
 395         int value2
 396 )
 397 {
 398
 399 #ifdef  __MigPackStructs
 400 #pragma pack(4)
 401 #endif
 402         typedef struct {
 403                 mach_msg_header_t Head;
 404                 NDR_record_t NDR;
 405                 int refnum;
 406                 client_name_t client_name;
 407                 int notify;
 408                 message_t message;
 409                 int value1;
 410                 int value2;
 411         } Request;
 412 #ifdef  __MigPackStructs
 413 #pragma pack()
 414 #endif
 415         /*
 416          * typedef struct {
 417          *      mach_msg_header_t Head;
 418          *      NDR_record_t NDR;
 419          *      kern_return_t RetCode;
 420          * } mig_reply_error_t;
 421          */
 422
 423         union {
 424                 Request In;
 425         } Mess;
 426
 427         Request *InP = &Mess.In;
 428
 429         mach_msg_return_t msg_result;
 430
 431 #ifdef  __MIG_check__Reply__rpc_jack_client_async_notify_t__defined
 432         kern_return_t check_result;
 433 #endif  /* __MIG_check__Reply__rpc_jack_client_async_notify_t__defined */
 434
 435         __DeclareSendSimple(1001, "rpc_jack_client_async_notify")
 436
 437         InP->NDR = NDR_record;
 438
 439         InP->refnum = refnum;
 440
 441         (void) mig_strncpy(InP->client_name, client_name, 64);
 442
 443         InP->notify = notify;
 444
 445         (void) mig_strncpy(InP->message, message, 256);
 446
 447         InP->value1 = value1;
 448
 449         InP->value2 = value2;
 450
 451         InP->Head.msgh_bits =
 452                 MACH_MSGH_BITS(19, 0);
 453         /* msgh_size passed as argument */
 454         InP->Head.msgh_request_port = client_port;
 455         InP->Head.msgh_reply_port = MACH_PORT_NULL;
 456         InP->Head.msgh_id = 1001;
 457
 458         __BeforeSendSimple(1001, "rpc_jack_client_async_notify")
 459         msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_SEND_TIMEOUT|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, 5000, MACH_PORT_NULL);
 460         __AfterSendSimple(1001, "rpc_jack_client_async_notify")
 461
 462         if (msg_result == MACH_SEND_TIMED_OUT) {
 463         }
 464
 465         return msg_result;
 466 }