dlls/rpcrt4/rpcrt4_main.c

   1 /*
   2  *  RPCRT4
   3  *
   4  * Copyright 2000 Huw D M Davies for Codeweavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * WINE RPC TODO's (and a few TODONT's)
  21  *
  22  * - widl is like MIDL for wine.  For wine to be a useful RPC platform, quite
  23  *   a bit of work needs to be done here.  widl currently doesn't generate stubs
  24  *   for RPC invocation -- it will need to; this is tricky because the MIDL compiler
  25  *   does some really weird stuff.  Then again, we don't necessarily have to
  26  *   make widl work like MIDL, so it could be worse.  Lately Ove has been working on
  27  *   some widl enhancements.
  28  *
  29  * - RPC has a quite featureful error handling mechanism; basically none of this is
  30  *   implemented right now.
  31  *
  32  * - There are several different memory allocation schemes for MSRPC.
  33  *   I don't even understand what they all are yet, much less have them
  34  *   properly implemented.  Surely we are supposed to be doing something with
  35  *   the user-provided allocation/deallocation functions, but so far,
  36  *   I don't think we are doing this...
  37  *
  38  * - MSRPC provides impersonation capabilities which currently are not possible
  39  *   to implement in wine.  At the very least we should implement the authorization
  40  *   API's & gracefully ignore the irrelevant stuff (to a small extent we already do).
  41  *
  42  * - Some transports are not yet implemented.  The existing transport implementations
  43  *   are incomplete and many seem to be buggy
  44  *
  45  * - The various transports that we do support ought to be supported in a more
  46  *   object-oriented manner, like in DCE's RPC implementation, instead of cluttering
  47  *   up the code with conditionals like we do now.
  48  *
  49  * - Data marshalling: So far, only the very beginnings of an implementation
  50  *   exist in wine.  NDR protocol itself is documented, but the MS API's to
  51  *   convert data-types in memory into NDR are not.  This is a bit of a challenge,
  52  *   but it is at the top of Greg's queue and should be improving soon.
  53  *
  54  * - ORPC is RPC for OLE; once we have a working RPC framework, we can
  55  *   use it to implement out-of-process OLE client/server communications.
  56  *   ATM there is a 100% disconnect between the marshalling in the OLE DLL's
  57  *   and the marshalling going on here.  This is a good thing, since marshalling
  58  *   doesn't work yet.  But once it does, obviously there will be the opportunity
  59  *   to implement out-of-process OLE using wine's rpcrt4 or some derivative.
  60  *   This may require some collaboration between the RPC workers and the OLE
  61  *   workers, of course.
  62  *
  63  * - In-source API Documentation, at least for those functions which we have
  64  *   implemented, but preferably for everything we can document, would be nice.
  65  *   Some stuff is undocumented by Microsoft and we are guessing how to implement
  66  *   (in these cases we should document the behavior we implemented, or, if there
  67  *   is no implementation, at least hazard some kind of guess, and put a few
  68  *   question marks after it ;) ).
  69  *
  70  * - Stubs.  Lots of stuff is defined in Microsoft's headers, including undocumented
  71  *   stuff.  So let's make a stub-farm and populate it with as many rpcrt4 api's as
  72  *   we can stand, so people don't get unimplemented function exceptions.
  73  *
  74  * - Name services: this part hasn't even been started.
  75  *
  76  * - Concurrency: right now I have not tested more than one request at a time;
  77  *   we are supposed to be able to do this, and to queue requests which exceed the
  78  *   concurrency limit.
  79  *
  80  * - Protocol Towers: Totally unimplemented.... I think.
  81  *
  82  * - Context Handle Rundown: whatever that is.
  83  *
  84  * - Nested RPC's: Totally unimplemented.
  85  *
  86  * - Statistics: we are supposed to be keeping various counters.  we aren't.
  87  *
  88  * - Connectionless RPC: unimplemented (DNE in win9x so not a top priority)
  89  *
  90  * - XML RPC: Dunno if microsoft does it... but we'd might as well just for kicks.
  91  *
  92  * - ...?  More stuff I haven't thought of.  If you think of more RPC todo's drop me
  93  *   an e-mail <gmturner007@ameritech.net> or send a patch to wine-patches.
  94  */
  95
  96 #include "config.h"
  97
  98 #include <stdio.h>
  99 #include <stdlib.h>
 100 #include <string.h>
 101 #include <time.h>
 102 #ifdef HAVE_SYS_TIME_H
 103 # include <sys/time.h>
 104 #endif
 105 #ifdef HAVE_UNISTD_H
 106 # include <unistd.h>
 107 #endif
 108
 109 #include "windef.h"
 110 #include "winerror.h"
 111 #include "winbase.h"
 112 #include "wine/unicode.h"
 113 #include "rpc.h"
 114
 115 #include "ole2.h"
 116 #include "rpcndr.h"
 117 #include "rpcproxy.h"
 118
 119 #ifdef HAVE_SYS_FILE_H
 120 # include <sys/file.h>
 121 #endif
 122 #ifdef HAVE_SYS_IOCTL_H
 123 # include <sys/ioctl.h>
 124 #endif
 125 #ifdef HAVE_SYS_SOCKET_H
 126 # include <sys/socket.h>
 127 #endif
 128 #ifdef HAVE_SYS_SOCKIO_H
 129 # include <sys/sockio.h>
 130 #endif
 131 #ifdef HAVE_NET_IF_H
 132 # include <net/if.h>
 133 #endif
 134 #ifdef HAVE_NETINET_IN_H
 135 # include <netinet/in.h>
 136 #endif
 137
 138 #include "rpc_binding.h"
 139 #include "rpcss_np_client.h"
 140
 141 #include "wine/debug.h"
 142
 143 WINE_DEFAULT_DEBUG_CHANNEL(ole);
 144
 145 static UUID uuid_nil;
 146 static HANDLE master_mutex;
 147
 148 HANDLE RPCRT4_GetMasterMutex(void)
 149 {
 150     return master_mutex;
 151 }
 152
 153 /***********************************************************************
 154  * DllMain
 155  *
 156  * PARAMS
 157  *     hinstDLL    [I] handle to the DLL's instance
 158  *     fdwReason   [I]
 159  *     lpvReserved [I] reserved, must be NULL
 160  *
 161  * RETURNS
 162  *     Success: TRUE
 163  *     Failure: FALSE
 164  */
 165
 166 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 167 {
 168     switch (fdwReason) {
 169     case DLL_PROCESS_ATTACH:
 170         master_mutex = CreateMutexA( NULL, FALSE, RPCSS_MASTER_MUTEX_NAME);
 171         if (!master_mutex)
 172           ERR("Failed to create master mutex\n");
 173         break;
 174
 175     case DLL_PROCESS_DETACH:
 176         CloseHandle(master_mutex);
 177         master_mutex = NULL;
 178         break;
 179     }
 180
 181     return TRUE;
 182 }
 183
 184 /*************************************************************************
 185  *           RpcStringFreeA   [RPCRT4.@]
 186  *
 187  * Frees a character string allocated by the RPC run-time library.
 188  *
 189  * RETURNS
 190  *
 191  *  S_OK if successful.
 192  */
 193 RPC_STATUS WINAPI RpcStringFreeA(unsigned char** String)
 194 {
 195   HeapFree( GetProcessHeap(), 0, *String);
 196
 197   return RPC_S_OK;
 198 }
 199
 200 /*************************************************************************
 201  *           RpcStringFreeW   [RPCRT4.@]
 202  *
 203  * Frees a character string allocated by the RPC run-time library.
 204  *
 205  * RETURNS
 206  *
 207  *  S_OK if successful.
 208  */
 209 RPC_STATUS WINAPI RpcStringFreeW(unsigned short** String)
 210 {
 211   HeapFree( GetProcessHeap(), 0, *String);
 212
 213   return RPC_S_OK;
 214 }
 215
 216 /*************************************************************************
 217  *           RpcRaiseException   [RPCRT4.@]
 218  *
 219  * Raises an exception.
 220  */
 221 void WINAPI RpcRaiseException(RPC_STATUS exception)
 222 {
 223   /* FIXME: translate exception? */
 224   RaiseException(exception, 0, 0, NULL);
 225 }
 226
 227 /*************************************************************************
 228  * UuidCompare [RPCRT4.@]
 229  *
 230  * (an educated-guess implementation)
 231  *
 232  * PARAMS
 233  *     UUID *Uuid1        [I] Uuid to compare
 234  *     UUID *Uuid2        [I] Uuid to compare
 235  *     RPC_STATUS *Status [O] returns RPC_S_OK
 236  *
 237  * RETURNS
 238  *     -1 if Uuid1 is less than Uuid2
 239  *     0  if Uuid1 and Uuid2 are equal
 240  *     1  if Uuid1 is greater than Uuid2
 241  */
 242 int WINAPI UuidCompare(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
 243 {
 244   TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
 245   *Status = RPC_S_OK;
 246   if (!Uuid1) Uuid1 = &uuid_nil;
 247   if (!Uuid2) Uuid2 = &uuid_nil;
 248   if (Uuid1 == Uuid2) return 0;
 249   return memcmp(Uuid1, Uuid2, sizeof(UUID));
 250 }
 251
 252 /*************************************************************************
 253  * UuidEqual [RPCRT4.@]
 254  *
 255  * PARAMS
 256  *     UUID *Uuid1        [I] Uuid to compare
 257  *     UUID *Uuid2        [I] Uuid to compare
 258  *     RPC_STATUS *Status [O] returns RPC_S_OK
 259  *
 260  * RETURNS
 261  *     TRUE/FALSE
 262  */
 263 int WINAPI UuidEqual(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
 264 {
 265   TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
 266   return !UuidCompare(Uuid1, Uuid2, Status);
 267 }
 268
 269 /*************************************************************************
 270  * UuidIsNil [RPCRT4.@]
 271  *
 272  * PARAMS
 273  *     UUID *Uuid         [I] Uuid to compare
 274  *     RPC_STATUS *Status [O] retuns RPC_S_OK
 275  *
 276  * RETURNS
 277  *     TRUE/FALSE
 278  */
 279 int WINAPI UuidIsNil(UUID *uuid, RPC_STATUS *Status)
 280 {
 281   TRACE("(%s)\n", debugstr_guid(uuid));
 282   *Status = RPC_S_OK;
 283   if (!uuid) return TRUE;
 284   return !memcmp(uuid, &uuid_nil, sizeof(UUID));
 285 }
 286
 287  /*************************************************************************
 288  * UuidCreateNil [RPCRT4.@]
 289  *
 290  * PARAMS
 291  *     UUID *Uuid [O] returns a nil UUID
 292  *
 293  * RETURNS
 294  *     RPC_S_OK
 295  */
 296 RPC_STATUS WINAPI UuidCreateNil(UUID *Uuid)
 297 {
 298   *Uuid = uuid_nil;
 299   return RPC_S_OK;
 300 }
 301
 302 /*************************************************************************
 303  *           UuidCreate   [RPCRT4.@]
 304  *
 305  * Creates a 128bit UUID.
 306  * Implemented according the DCE specification for UUID generation.
 307  * Code is based upon uuid library in e2fsprogs by Theodore Ts'o.
 308  * Copyright (C) 1996, 1997 Theodore Ts'o.
 309  *
 310  * RETURNS
 311  *
 312  *  S_OK if successful.
 313  */
 314 RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
 315 {
 316    static char has_init = 0;
 317    static unsigned char a[6];
 318    static int                      adjustment = 0;
 319    static struct timeval           last = {0, 0};
 320    static WORD                     clock_seq;
 321    struct timeval                  tv;
 322    unsigned long long              clock_reg;
 323    DWORD clock_high, clock_low;
 324    WORD temp_clock_seq, temp_clock_mid, temp_clock_hi_and_version;
 325 #ifdef HAVE_NET_IF_H
 326    int             sd;
 327    struct ifreq    ifr, *ifrp;
 328    struct ifconf   ifc;
 329    char buf[1024];
 330    int             n, i;
 331 #endif
 332
 333    /* Have we already tried to get the MAC address? */
 334    if (!has_init) {
 335 #ifdef HAVE_NET_IF_H
 336       /* BSD 4.4 defines the size of an ifreq to be
 337        * max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len
 338        * However, under earlier systems, sa_len isn't present, so
 339        *  the size is just sizeof(struct ifreq)
 340        */
 341 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 342 #  ifndef max
 343 #   define max(a,b) ((a) > (b) ? (a) : (b))
 344 #  endif
 345 #  define ifreq_size(i) max(sizeof(struct ifreq),\
 346 sizeof((i).ifr_name)+(i).ifr_addr.sa_len)
 347 # else
 348 #  define ifreq_size(i) sizeof(struct ifreq)
 349 # endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 350
 351       sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
 352       if (sd < 0) {
 353          /* if we can't open a socket, just use random numbers */
 354          /* set the multicast bit to prevent conflicts with real cards */
 355          a[0] = (rand() & 0xff) | 0x80;
 356          a[1] = rand() & 0xff;
 357          a[2] = rand() & 0xff;
 358          a[3] = rand() & 0xff;
 359          a[4] = rand() & 0xff;
 360          a[5] = rand() & 0xff;
 361       } else {
 362          memset(buf, 0, sizeof(buf));
 363          ifc.ifc_len = sizeof(buf);
 364          ifc.ifc_buf = buf;
 365          /* get the ifconf interface */
 366          if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0) {
 367             close(sd);
 368             /* no ifconf, so just use random numbers */
 369             /* set the multicast bit to prevent conflicts with real cards */
 370             a[0] = (rand() & 0xff) | 0x80;
 371             a[1] = rand() & 0xff;
 372             a[2] = rand() & 0xff;
 373             a[3] = rand() & 0xff;
 374             a[4] = rand() & 0xff;
 375             a[5] = rand() & 0xff;
 376          } else {
 377             /* loop through the interfaces, looking for a valid one */
 378             n = ifc.ifc_len;
 379             for (i = 0; i < n; i+= ifreq_size(ifr) ) {
 380                ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i);
 381                strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ);
 382                /* try to get the address for this interface */
 383 # ifdef SIOCGIFHWADDR
 384                if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0)
 385                    continue;
 386                memcpy(a, (unsigned char *)&ifr.ifr_hwaddr.sa_data, 6);
 387 # else
 388 #  ifdef SIOCGENADDR
 389                if (ioctl(sd, SIOCGENADDR, &ifr) < 0)
 390                    continue;
 391                memcpy(a, (unsigned char *) ifr.ifr_enaddr, 6);
 392 #  else
 393                /* XXX we don't have a way of getting the hardware address */
 394                close(sd);
 395                a[0] = 0;
 396                break;
 397 #  endif /* SIOCGENADDR */
 398 # endif /* SIOCGIFHWADDR */
 399                /* make sure it's not blank */
 400                if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5])
 401                    continue;
 402
 403                goto valid_address;
 404             }
 405             /* if we didn't find a valid address, make a random one */
 406             /* once again, set multicast bit to avoid conflicts */
 407             a[0] = (rand() & 0xff) | 0x80;
 408             a[1] = rand() & 0xff;
 409             a[2] = rand() & 0xff;
 410             a[3] = rand() & 0xff;
 411             a[4] = rand() & 0xff;
 412             a[5] = rand() & 0xff;
 413
 414             valid_address:
 415             close(sd);
 416          }
 417       }
 418 #else
 419       /* no networking info, so generate a random address */
 420       a[0] = (rand() & 0xff) | 0x80;
 421       a[1] = rand() & 0xff;
 422       a[2] = rand() & 0xff;
 423       a[3] = rand() & 0xff;
 424       a[4] = rand() & 0xff;
 425       a[5] = rand() & 0xff;
 426 #endif /* HAVE_NET_IF_H */
 427       has_init = 1;
 428    }
 429
 430    /* generate time element of GUID */
 431
 432    /* Assume that the gettimeofday() has microsecond granularity */
 433 #define MAX_ADJUSTMENT 10
 434
 435    try_again:
 436    gettimeofday(&tv, 0);
 437    if ((last.tv_sec == 0) && (last.tv_usec == 0)) {
 438       clock_seq = ((rand() & 0xff) << 8) + (rand() & 0xff);
 439       clock_seq &= 0x1FFF;
 440       last = tv;
 441       last.tv_sec--;
 442    }
 443    if ((tv.tv_sec < last.tv_sec) ||
 444        ((tv.tv_sec == last.tv_sec) &&
 445         (tv.tv_usec < last.tv_usec))) {
 446       clock_seq = (clock_seq+1) & 0x1FFF;
 447       adjustment = 0;
 448    } else if ((tv.tv_sec == last.tv_sec) &&
 449               (tv.tv_usec == last.tv_usec)) {
 450       if (adjustment >= MAX_ADJUSTMENT)
 451           goto try_again;
 452       adjustment++;
 453    } else
 454        adjustment = 0;
 455
 456    clock_reg = tv.tv_usec*10 + adjustment;
 457    clock_reg += ((unsigned long long) tv.tv_sec)*10000000;
 458    clock_reg += (((unsigned long long) 0x01B21DD2) << 32) + 0x13814000;
 459
 460    clock_high = clock_reg >> 32;
 461    clock_low = clock_reg;
 462    temp_clock_seq = clock_seq | 0x8000;
 463    temp_clock_mid = (WORD)clock_high;
 464    temp_clock_hi_and_version = (clock_high >> 16) | 0x1000;
 465
 466    /* pack the information into the GUID structure */
 467
 468    ((unsigned char*)&Uuid->Data1)[3] = (unsigned char)clock_low;
 469    clock_low >>= 8;
 470    ((unsigned char*)&Uuid->Data1)[2] = (unsigned char)clock_low;
 471    clock_low >>= 8;
 472    ((unsigned char*)&Uuid->Data1)[1] = (unsigned char)clock_low;
 473    clock_low >>= 8;
 474    ((unsigned char*)&Uuid->Data1)[0] = (unsigned char)clock_low;
 475
 476    ((unsigned char*)&Uuid->Data2)[1] = (unsigned char)temp_clock_mid;
 477    temp_clock_mid >>= 8;
 478    ((unsigned char*)&Uuid->Data2)[0] = (unsigned char)temp_clock_mid;
 479
 480    ((unsigned char*)&Uuid->Data3)[1] = (unsigned char)temp_clock_hi_and_version;
 481    temp_clock_hi_and_version >>= 8;
 482    ((unsigned char*)&Uuid->Data3)[0] = (unsigned char)temp_clock_hi_and_version;
 483
 484    ((unsigned char*)Uuid->Data4)[1] = (unsigned char)temp_clock_seq;
 485    temp_clock_seq >>= 8;
 486    ((unsigned char*)Uuid->Data4)[0] = (unsigned char)temp_clock_seq;
 487
 488    ((unsigned char*)Uuid->Data4)[2] = a[0];
 489    ((unsigned char*)Uuid->Data4)[3] = a[1];
 490    ((unsigned char*)Uuid->Data4)[4] = a[2];
 491    ((unsigned char*)Uuid->Data4)[5] = a[3];
 492    ((unsigned char*)Uuid->Data4)[6] = a[4];
 493    ((unsigned char*)Uuid->Data4)[7] = a[5];
 494
 495    TRACE("%s\n", debugstr_guid(Uuid));
 496
 497    return RPC_S_OK;
 498 }
 499
 500
 501 /*************************************************************************
 502  *           UuidCreateSequential   [RPCRT4.@]
 503  *
 504  * Creates a 128bit UUID by calling UuidCreate.
 505  * New API in Win 2000
 506  */
 507 RPC_STATUS WINAPI UuidCreateSequential(UUID *Uuid)
 508 {
 509    return UuidCreate (Uuid);
 510 }
 511
 512
 513 /*************************************************************************
 514  *           UuidHash   [RPCRT4.@]
 515  *
 516  * Generates a hash value for a given UUID
 517  *
 518  * Code based on FreeDCE implementation
 519  *
 520  */
 521 unsigned short WINAPI UuidHash(UUID *uuid, RPC_STATUS *Status)
 522 {
 523   BYTE *data = (BYTE*)uuid;
 524   short c0 = 0, c1 = 0, x, y;
 525   int i;
 526
 527   if (!uuid) data = (BYTE*)(uuid = &uuid_nil);
 528
 529   TRACE("(%s)\n", debugstr_guid(uuid));
 530
 531   for (i=0; i<sizeof(UUID); i++) {
 532     c0 += data[i];
 533     c1 += c0;
 534   }
 535
 536   x = -c1 % 255;
 537   if (x < 0) x += 255;
 538
 539   y = (c1 - c0) % 255;
 540   if (y < 0) y += 255;
 541
 542   *Status = RPC_S_OK;
 543   return y*256 + x;
 544 }
 545
 546 /*************************************************************************
 547  *           UuidToStringA   [RPCRT4.@]
 548  *
 549  * Converts a UUID to a string.
 550  *
 551  * UUID format is 8 hex digits, followed by a hyphen then three groups of
 552  * 4 hex digits each followed by a hyphen and then 12 hex digits
 553  *
 554  * RETURNS
 555  *
 556  *  S_OK if successful.
 557  *  S_OUT_OF_MEMORY if unsucessful.
 558  */
 559 RPC_STATUS WINAPI UuidToStringA(UUID *Uuid, unsigned char** StringUuid)
 560 {
 561   *StringUuid = HeapAlloc( GetProcessHeap(), 0, sizeof(char) * 37);
 562
 563   if(!(*StringUuid))
 564     return RPC_S_OUT_OF_MEMORY;
 565
 566   if (!Uuid) Uuid = &uuid_nil;
 567
 568   sprintf(*StringUuid, "%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 569                  Uuid->Data1, Uuid->Data2, Uuid->Data3,
 570                  Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
 571                  Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
 572                  Uuid->Data4[6], Uuid->Data4[7] );
 573
 574   return RPC_S_OK;
 575 }
 576
 577 /*************************************************************************
 578  *           UuidToStringW   [RPCRT4.@]
 579  *
 580  * Converts a UUID to a string.
 581  *
 582  *  S_OK if successful.
 583  *  S_OUT_OF_MEMORY if unsucessful.
 584  */
 585 RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, unsigned short** StringUuid)
 586 {
 587   char buf[37];
 588
 589   if (!Uuid) Uuid = &uuid_nil;
 590
 591   sprintf(buf, "%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 592                Uuid->Data1, Uuid->Data2, Uuid->Data3,
 593                Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
 594                Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
 595                Uuid->Data4[6], Uuid->Data4[7] );
 596
 597   *StringUuid = RPCRT4_strdupAtoW(buf);
 598
 599   if(!(*StringUuid))
 600     return RPC_S_OUT_OF_MEMORY;
 601
 602   return RPC_S_OK;
 603 }
 604
 605 static const BYTE hex2bin[] =
 606 {
 607     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,        /* 0x00 */
 608     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,        /* 0x10 */
 609     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,        /* 0x20 */
 610     0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,        /* 0x30 */
 611     0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0,  /* 0x40 */
 612     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,        /* 0x50 */
 613     0,10,11,12,13,14,15                     /* 0x60 */
 614 };
 615
 616 /***********************************************************************
 617  *              UuidFromStringA (RPCRT4.@)
 618  */
 619 RPC_STATUS WINAPI UuidFromStringA(unsigned char* str, UUID *uuid)
 620 {
 621     BYTE *s = (BYTE *)str;
 622     int i;
 623
 624     if (!s) return UuidCreateNil( uuid );
 625
 626     if (strlen(s) != 36) return RPC_S_INVALID_STRING_UUID;
 627
 628     if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
 629         return RPC_S_INVALID_STRING_UUID;
 630
 631     for (i=0; i<36; i++)
 632     {
 633         if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
 634         if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
 635     }
 636
 637     /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
 638
 639     uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
 640                    hex2bin[s[4]] << 12 | hex2bin[s[5]]  << 8 | hex2bin[s[6]]  << 4 | hex2bin[s[7]]);
 641     uuid->Data2 =  hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
 642     uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
 643
 644     /* these are just sequential bytes */
 645     uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
 646     uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
 647     uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
 648     uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
 649     uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
 650     uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
 651     uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
 652     uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
 653     return RPC_S_OK;
 654 }
 655
 656
 657 /***********************************************************************
 658  *              UuidFromStringW (RPCRT4.@)
 659  */
 660 RPC_STATUS WINAPI UuidFromStringW(unsigned short* s, UUID *uuid)
 661 {
 662     int i;
 663
 664     if (!s) return UuidCreateNil( uuid );
 665
 666     if (strlenW(s) != 36) return RPC_S_INVALID_STRING_UUID;
 667
 668     if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
 669         return RPC_S_INVALID_STRING_UUID;
 670
 671     for (i=0; i<36; i++)
 672     {
 673         if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
 674         if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
 675     }
 676
 677     /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
 678
 679     uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
 680                    hex2bin[s[4]] << 12 | hex2bin[s[5]]  << 8 | hex2bin[s[6]]  << 4 | hex2bin[s[7]]);
 681     uuid->Data2 =  hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
 682     uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
 683
 684     /* these are just sequential bytes */
 685     uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
 686     uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
 687     uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
 688     uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
 689     uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
 690     uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
 691     uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
 692     uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
 693     return RPC_S_OK;
 694 }
 695
 696 /***********************************************************************
 697  *              DllRegisterServer (RPCRT4.@)
 698  */
 699
 700 HRESULT WINAPI RPCRT4_DllRegisterServer( void )
 701 {
 702     FIXME( "(): stub\n" );
 703     return S_OK;
 704 }
 705
 706 BOOL RPCRT4_StartRPCSS(void)
 707 {
 708     PROCESS_INFORMATION pi;
 709     STARTUPINFOA si;
 710     static char cmd[6];
 711     BOOL rslt;
 712
 713     ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
 714     ZeroMemory(&si, sizeof(STARTUPINFOA));
 715     si.cb = sizeof(STARTUPINFOA);
 716
 717     /* apparently it's not OK to use a constant string below */
 718     CopyMemory(cmd, "rpcss", 6);
 719
 720     /* FIXME: will this do the right thing when run as a test? */
 721     rslt = CreateProcessA(
 722         NULL,           /* executable */
 723         cmd,            /* command line */
 724         NULL,           /* process security attributes */
 725         NULL,           /* primary thread security attributes */
 726         FALSE,          /* inherit handles */
 727         0,              /* creation flags */
 728         NULL,           /* use parent's environment */
 729         NULL,           /* use parent's current directory */
 730         &si,            /* STARTUPINFO pointer */
 731         &pi             /* PROCESS_INFORMATION */
 732     );
 733
 734     if (rslt) {
 735       CloseHandle(pi.hProcess);
 736       CloseHandle(pi.hThread);
 737     }
 738
 739     return rslt;
 740 }
 741
 742 /***********************************************************************
 743  *           RPCRT4_RPCSSOnDemandCall (internal)
 744  *
 745  * Attempts to send a message to the RPCSS process
 746  * on the local machine, invoking it if necessary.
 747  * For remote RPCSS calls, use.... your imagination.
 748  *
 749  * PARAMS
 750  *     msg             [I] pointer to the RPCSS message
 751  *     vardata_payload [I] pointer vardata portion of the RPCSS message
 752  *     reply           [O] pointer to reply structure
 753  *
 754  * RETURNS
 755  *     TRUE if successful
 756  *     FALSE otherwise
 757  */
 758 BOOL RPCRT4_RPCSSOnDemandCall(PRPCSS_NP_MESSAGE msg, char *vardata_payload, PRPCSS_NP_REPLY reply)
 759 {
 760     HANDLE client_handle;
 761     int i, j = 0;
 762
 763     TRACE("(msg == %p, vardata_payload == %p, reply == %p)\n", msg, vardata_payload, reply);
 764
 765     client_handle = RPCRT4_RpcssNPConnect();
 766
 767     while (!client_handle) {
 768         /* start the RPCSS process */
 769         if (!RPCRT4_StartRPCSS()) {
 770             ERR("Unable to start RPCSS process.\n");
 771             return FALSE;
 772         }
 773         /* wait for a connection (w/ periodic polling) */
 774         for (i = 0; i < 60; i++) {
 775             Sleep(200);
 776             client_handle = RPCRT4_RpcssNPConnect();
 777             if (client_handle) break;
 778         }
 779         /* we are only willing to try twice */
 780         if (j++ >= 1) break;
 781     }
 782
 783     if (!client_handle) {
 784         /* no dice! */
 785         ERR("Unable to connect to RPCSS process!\n");
 786         SetLastError(RPC_E_SERVER_DIED_DNE);
 787         return FALSE;
 788     }
 789
 790     /* great, we're connected.  now send the message */
 791     if (!RPCRT4_SendReceiveNPMsg(client_handle, msg, vardata_payload, reply)) {
 792         ERR("Something is amiss: RPC_SendReceive failed.\n");
 793         return FALSE;
 794     }
 795
 796     return TRUE;
 797 }