Ignore:
Timestamp:
Oct 20, 1999, 12:03:55 PM (26 years ago)
Author:
phaller
Message:

Fix: WSA async rewrite

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wsock32/async.cpp

    r1367 r1372  
    1 /* $Id: async.cpp,v 1.1 1999-10-20 01:18:28 phaller Exp $ */
     1/* $Id: async.cpp,v 1.2 1999-10-20 10:03:52 phaller Exp $ */
    22
    33/*
    … …  
    2323#include <odinwrap.h>
    2424#include <os2sel.h>
    25 #include <os2win.h>
    26 //#include <wsock32.h>
     25#define INCL_DOSERRORS
     26#define INCL_DOSSEMAPHORES
     27#include <os2.h>
     28
     29#include <netdb.h>
     30#include <nerrno.h>
     31#include <sys/socket.h>
     32#include <wsock32const.h>
     33
     34#include <process.h>
     35#include <string.h>
     36#include <stdlib.h>
     37
    2738#include <misc.h>
     39
     40
     41/*****************************************************************************
     42 * Definitions                                                               *
     43 *****************************************************************************/
     44
     45ODINDEBUGCHANNEL(WSOCK32-ASYNC)
     46
    2847
    2948
    … …  
    7392  ULONG  ul2;
    7493  ULONG  ul3;
    75   ULONG  ul4;
    76   ULONG  ul5;
    7794
    7895} ASYNCREQUEST, *PASYNCREQUEST;
    7996
    8097
     98/*****************************************************************************
     99 * Prototypes                                                                *
     100 *****************************************************************************/
     101
     102void _Optlink WorkerThreadProc(void* pParam);
     103BOOL _System PostMessageA(HWND hwnd, UINT ulMessage, WPARAM wParam, LPARAM lParam);
     104
     105void _System SetLastError(int iError);
     106int  _System GetLastError(void);
     107#define WSASetLastError(a) SetLastError(a)
     108
    81109
    82110/*****************************************************************************
    … …  
    86114class WSAAsyncWorker
    87115{
    88   // private members
    89   PASYNCREQUEST pRequestHead = NULL; // chain root
    90   PASYNCREQUEST pRequestTail = NULL; // chain root
    91   TID           tidWorker    = 0;    // worker thread id
    92   HEV           hevRequest;          // fired upon new request
    93   HMUTEX        hmtxRequestQueue;    // request queue protection
    94 
    95116  // public members
    96117  public:
    … …  
    98119    ~WSAAsyncWorker();                            // destructor
    99120
    100     PASYNCREQUEST createRequest  (HWND  hwnd,
     121    PASYNCREQUEST createRequest  (ULONG ulType,
     122                                  HWND  hwnd,
    101123                                  ULONG ulMessage,
     124                                  PVOID pBuffer,
     125                                  ULONG ulBufferLength,
    102126                                  ULONG ul1 = 0,
    103127                                  ULONG ul2 = 0,
    104                                   ULONG ul3 = 0,
    105                                   ULONG ul4 = 0,
    106                                   ULONG ul5 = 0);
     128                                  ULONG ul3 = 0);
     129
    107130    void          pushRequest    (PASYNCREQUEST pRequest); // put request on queue
    108 
     131    BOOL          deleteRequest  (PASYNCREQUEST pRequest); // remove particular request
     132
     133    // the thread procedure
     134    friend void _Optlink WorkerThreadProc(void* pParam);
    109135
    110136
    111137  // protected members
    112138  protected:
    113     BOOL          fTerminate = FALSE;                      // got to die ?
     139    PASYNCREQUEST pRequestHead;        // chain root
     140    PASYNCREQUEST pRequestTail;        // chain root
     141    TID           tidWorker;           // worker thread id
     142    HEV           hevRequest;          // fired upon new request
     143    HMTX          hmtxRequestQueue;    // request queue protection
     144    BOOL          fTerminate;          // got to die ?
    114145
    115146    TID           startWorker    (void);                   // start worker thread
    … …  
    117148    int           dispatchRequest(PASYNCREQUEST pRequest); // complete request
    118149    PASYNCREQUEST popRequest     (void);                   // get one request from queue
    119     BOOL          deleteRequest  (PASYNCREQUEST pRequest); // remove particular request
    120150
    121151    void          lockQueue      (void);                   // enter mutex
    … …  
    132162
    133163
     164/*****************************************************************************
     165 * Local variables                                                           *
     166 *****************************************************************************/
     167
     168static WSAAsyncWorker* wsaWorker = NULL;
     169
     170
     171/*****************************************************************************
     172 * Name      :
     173 * Purpose   :
     174 * Parameters:
     175 * Variables :
     176 * Result    :
     177 * Remark    :
     178 * Status    : UNTESTED STUB
     179 *
     180 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     181 *****************************************************************************/
    134182// constructor
    135183WSAAsyncWorker::WSAAsyncWorker(void)
    136184{
     185  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::WSAAsyncWorker\n"));
     186
     187  pRequestHead = NULL;  // chain root
     188  pRequestTail = NULL;  // chain root
     189  tidWorker    = 0;     // worker thread id
     190  fTerminate   = FALSE; // got to die ?
     191
    137192  startWorker();
    138193}
    139194
    140195
     196/*****************************************************************************
     197 * Name      :
     198 * Purpose   :
     199 * Parameters:
     200 * Variables :
     201 * Result    :
     202 * Remark    :
     203 * Status    : UNTESTED STUB
     204 *
     205 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     206 *****************************************************************************/
    141207// destructor
    142208WSAAsyncWorker::~WSAAsyncWorker(void)
    143209{
     210  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::~WSAAsyncWorker (%08xh)\n",
     211           this));
     212
    144213  // remove all requests
    145214  while (popRequest() != NULL);
    … …  
    158227
    159228
     229/*****************************************************************************
     230 * Name      :
     231 * Purpose   :
     232 * Parameters:
     233 * Variables :
     234 * Result    :
     235 * Remark    :
     236 * Status    : UNTESTED STUB
     237 *
     238 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     239 *****************************************************************************/
    160240// start worker thread if necessary
    161241TID WSAAsyncWorker::startWorker(void)
    162242{
    163243  APIRET rc;
     244
     245  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::startWorker (%08xh)\n",
     246           this));
    164247
    165248  if (tidWorker == 0)
    … …  
    192275
    193276    // create thread
     277#if defined(__IBMCPP__)
     278    tidWorker = _beginthread(WorkerThreadProc,
     279                             (PVOID)this,
     280                             4096,
     281                             NULL);
     282#else
    194283    tidWorker = _beginthread(WorkerThreadProc,
    195284                             (PVOID)this,
    196285                             4096);
     286#endif
    197287    if (tidWorker == -1)
    198288    {
    … …  
    208298
    209299
     300/*****************************************************************************
     301 * Name      :
     302 * Purpose   :
     303 * Parameters:
     304 * Variables :
     305 * Result    :
     306 * Remark    :
     307 * Status    : UNTESTED STUB
     308 *
     309 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     310 *****************************************************************************/
    210311// lock double-linked request chain
    211312void WSAAsyncWorker::lockQueue(void)
    212313{
    213   DosRequestMutex(hmtxRequestQueue, SEM_INDEFINITE_WAIT);
    214 }
    215 
    216 
     314  DosRequestMutexSem(hmtxRequestQueue, SEM_INDEFINITE_WAIT);
     315}
     316
     317
     318/*****************************************************************************
     319 * Name      :
     320 * Purpose   :
     321 * Parameters:
     322 * Variables :
     323 * Result    :
     324 * Remark    :
     325 * Status    : UNTESTED STUB
     326 *
     327 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     328 *****************************************************************************/
    217329// unlock double-linked request chain
    218330void WSAAsyncWorker::unlockQueue(void)
    219331{
    220   DosReleaseMutex(hmtxRequestQueue);
    221 }
    222 
    223 
     332  DosReleaseMutexSem(hmtxRequestQueue);
     333}
     334
     335
     336/*****************************************************************************
     337 * Name      :
     338 * Purpose   :
     339 * Parameters:
     340 * Variables :
     341 * Result    :
     342 * Remark    :
     343 * Status    : UNTESTED STUB
     344 *
     345 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     346 *****************************************************************************/
    224347// get request from queue
    225348PASYNCREQUEST WSAAsyncWorker::popRequest(void)
    … …  
    245368
    246369
     370/*****************************************************************************
     371 * Name      :
     372 * Purpose   :
     373 * Parameters:
     374 * Variables :
     375 * Result    :
     376 * Remark    :
     377 * Status    : UNTESTED STUB
     378 *
     379 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     380 *****************************************************************************/
    247381// insert request into queue
    248382void WSAAsyncWorker::pushRequest(PASYNCREQUEST pNew)
    … …  
    275409
    276410
     411/*****************************************************************************
     412 * Name      :
     413 * Purpose   :
     414 * Parameters:
     415 * Variables :
     416 * Result    :
     417 * Remark    :
     418 * Status    : UNTESTED STUB
     419 *
     420 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     421 *****************************************************************************/
    277422// delete particular request from queue
    278423BOOL WSAAsyncWorker::deleteRequest(PASYNCREQUEST pDelete)
    … …  
    321466        }
    322467
     468    delete pDelete; // free the memory
    323469    bResult = TRUE; // OK
    324470  }
    … …  
    329475
    330476
     477/*****************************************************************************
     478 * Name      :
     479 * Purpose   :
     480 * Parameters:
     481 * Variables :
     482 * Result    :
     483 * Remark    :
     484 * Status    : UNTESTED STUB
     485 *
     486 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     487 *****************************************************************************/
     488
     489PASYNCREQUEST WSAAsyncWorker::createRequest  (ULONG ulType,
     490                                              HWND  hwnd,
     491                                              ULONG ulMessage,
     492                                              PVOID pBuffer,
     493                                              ULONG ulBufferLength,
     494                                              ULONG ul1,
     495                                              ULONG ul2,
     496                                              ULONG ul3)
     497{
     498  PASYNCREQUEST pNew = new ASYNCREQUEST();
     499
     500  // fill the structure
     501  pNew->pPrev          = NULL;
     502  pNew->pNext          = NULL;
     503  pNew->ulType         = ulType;
     504  pNew->ulState        = RS_WAITING;
     505  pNew->hwnd           = hwnd;
     506  pNew->ulMessage      = ulMessage;
     507  pNew->pBuffer        = pBuffer;
     508  pNew->ulBufferLength = ulBufferLength;
     509  pNew->ul1            = ul1;
     510  pNew->ul2            = ul2;
     511  pNew->ul3            = ul3;
     512
     513  return pNew;
     514}
     515
     516
     517/*****************************************************************************
     518 * Name      :
     519 * Purpose   :
     520 * Parameters:
     521 * Variables :
     522 * Result    :
     523 * Remark    :
     524 * Status    : UNTESTED STUB
     525 *
     526 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     527 *****************************************************************************/
    331528
    332529void WSAAsyncWorker::asyncGetHostByAddr   (PASYNCREQUEST pRequest)
    … …  
    338535  USHORT          rc;
    339536
     537  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::asyncGetHostByAddr (%08xh, %08xh)\n",
     538           this,
     539           pRequest));
     540
    340541  // result buffer length
    341542  usLength = min(pRequest->ulBufferLength, sizeof(struct hostent));
    342543
    343544  // call API
    344   pHostent = gethostbyaddr((const char*)pRequest->u1,
    345                            (int)        pRequest->u2,
    346                            (int)        pRequest->u3);
     545  pHostent = gethostbyaddr((const char*)pRequest->ul1,
     546                           (int)        pRequest->ul2,
     547                           (int)        pRequest->ul3);
    347548  if (pHostent == NULL) // error ?
    348549  {
    … …  
    368569}
    369570
     571
     572/*****************************************************************************
     573 * Name      :
     574 * Purpose   :
     575 * Parameters:
     576 * Variables :
     577 * Result    :
     578 * Remark    :
     579 * Status    : UNTESTED STUB
     580 *
     581 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     582 *****************************************************************************/
     583
    370584void WSAAsyncWorker::asyncGetHostByName   (PASYNCREQUEST pRequest)
    371585{
    … …  
    376590  USHORT          rc;
    377591
     592  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::asyncGetHostByName (%08xh, %08xh)\n",
     593           this,
     594           pRequest));
     595
    378596  // result buffer length
    379597  usLength = min(pRequest->ulBufferLength, sizeof(struct hostent));
    380598
    381599  // call API
    382   pHostent = gethostbyname((const char*)pRequest->u1);
     600  pHostent = gethostbyname((const char*)pRequest->ul1);
    383601  if (pHostent == NULL) // error ?
    384602  {
    … …  
    405623
    406624
     625/*****************************************************************************
     626 * Name      :
     627 * Purpose   :
     628 * Parameters:
     629 * Variables :
     630 * Result    :
     631 * Remark    :
     632 * Status    : UNTESTED STUB
     633 *
     634 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     635 *****************************************************************************/
     636
    407637void WSAAsyncWorker::asyncGetProtoByName  (PASYNCREQUEST pRequest)
    408638{
    … …  
    413643  USHORT           rc;
    414644
     645  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::asyncGetProtoByName (%08xh, %08xh)\n",
     646           this,
     647           pRequest));
     648
    415649  // result buffer length
    416650  usLength = min(pRequest->ulBufferLength, sizeof(struct protoent));
    417651
    418652  // call API
    419   pProtoent = getprotobyname((const char*)pRequest->u1);
     653  pProtoent = getprotobyname((const char*)pRequest->ul1);
    420654  if (pProtoent == NULL) // error ?
    421655  {
    … …  
    441675}
    442676
     677
     678/*****************************************************************************
     679 * Name      :
     680 * Purpose   :
     681 * Parameters:
     682 * Variables :
     683 * Result    :
     684 * Remark    :
     685 * Status    : UNTESTED STUB
     686 *
     687 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     688 *****************************************************************************/
     689
    443690void WSAAsyncWorker::asyncGetProtoByNumber(PASYNCREQUEST pRequest)
    444691{
    … …  
    449696  USHORT           rc;
    450697
     698  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::asyncGetProtoByNumber (%08xh, %08xh)\n",
     699           this,
     700           pRequest));
     701
    451702  // result buffer length
    452703  usLength = min(pRequest->ulBufferLength, sizeof(struct protoent));
    453704
    454705  // call API
    455   pProtoent = getprotobyname((int)pRequest->u1);
     706  pProtoent = getprotobyname((const char*)pRequest->ul1);
    456707  if (pProtoent == NULL) // error ?
    457708  {
    … …  
    478729
    479730
     731/*****************************************************************************
     732 * Name      :
     733 * Purpose   :
     734 * Parameters:
     735 * Variables :
     736 * Result    :
     737 * Remark    :
     738 * Status    : UNTESTED STUB
     739 *
     740 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     741 *****************************************************************************/
     742
    480743void WSAAsyncWorker::asyncGetServByName(PASYNCREQUEST pRequest)
    481744{
    … …  
    486749  USHORT          rc;
    487750
     751  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::asyncGetServByName (%08xh, %08xh)\n",
     752           this,
     753           pRequest));
     754
    488755  // result buffer length
    489756  usLength = min(pRequest->ulBufferLength, sizeof(struct servent));
    490757
    491758  // call API
    492   pServent = getservbyname((const char*)pRequest->u1,
    493                            (const char*)pRequest->u2);
     759  pServent = getservbyname((const char*)pRequest->ul1,
     760                           (const char*)pRequest->ul2);
    494761  if (pServent == NULL) // error ?
    495762  {
    … …  
    516783
    517784
     785/*****************************************************************************
     786 * Name      :
     787 * Purpose   :
     788 * Parameters:
     789 * Variables :
     790 * Result    :
     791 * Remark    :
     792 * Status    : UNTESTED STUB
     793 *
     794 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     795 *****************************************************************************/
     796
    518797void WSAAsyncWorker::asyncGetServByPort(PASYNCREQUEST pRequest)
    519798{
    … …  
    524803  USHORT          rc;
    525804
     805  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::asyncGetServByPort (%08xh, %08xh)\n",
     806           this,
     807           pRequest));
     808
    526809  // result buffer length
    527810  usLength = min(pRequest->ulBufferLength, sizeof(struct servent));
    528811
    529812  // call API
    530   pServent = getservbyport((int        )pRequest->u1,
    531                            (const char*)pRequest->u2);
     813  pServent = getservbyport((int        )pRequest->ul1,
     814                           (const char*)pRequest->ul2);
    532815  if (pServent == NULL) // error ?
    533816  {
    … …  
    554837
    555838
     839/*****************************************************************************
     840 * Name      :
     841 * Purpose   :
     842 * Parameters:
     843 * Variables :
     844 * Result    :
     845 * Remark    :
     846 * Status    : UNTESTED STUB
     847 *
     848 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     849 *****************************************************************************/
    556850// process one request
    557851int WSAAsyncWorker::dispatchRequest(PASYNCREQUEST pRequest)
    558852{
     853  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::dispatchRequest (%08xh, %08xh)\n",
     854           this,
     855           pRequest));
     856
    559857  // check request state first
    560858  switch(pRequest->ulState)
    … …  
    574872
    575873  // OK, servicing request
    576   pRequest->ulStatus = RS_BUSY;
     874  pRequest->ulState = RS_BUSY;
    577875
    578876  switch(pRequest->ulType)
    … …  
    582880      return 1;
    583881
    584     case WSAASYNC_GETHOSTBYADDR:
    585       asyncGetHostByAddr(pRequest->hwnd,
    586                          pRequest->ulMessage,
    587                          (char*)pRequest->u1,
    588                          (int)  pRequest->u2,
    589                          (int)  pRequest->u3,
    590                          (char*)pRequest->u4,
    591                          (int)  pRequest->u5);
    592       return 1;
    593 
    594     case WSAASYNC_GETHOSTBYNAME:
    595       asyncGetHostByName(pRequest->hwnd,
    596                          pRequest->ulMessage,
    597                          (char*)pRequest->u1,
    598                          (char*)pRequest->u2,
    599                          (int)  pRequest->u3);
    600       break;
    601 
    602     case WSAASYNC_GETPROTOBYNAME:
    603       asyncGetProtoByName  (pRequest->hwnd,
    604                             pRequest->ulMessage,
    605                             (char*)pRequest->u1,
    606                             (char*)pRequest->u2,
    607                             (int)  pRequest->u3);
    608       break;
    609 
    610     case WSAASYNC_GETPROTOBYNUMBER:
    611       asyncGetProtoByNumber(pRequest->hwnd,
    612                             pRequest->ulMessage,
    613                             (int)  pRequest->u1,
    614                             (char*)pRequest->u2,
    615                             (int)  pRequest->u3);
    616       break;
    617 
    618     case WSAASYNC_GETSERVBYNAME:
    619       asyncGetServByName   (pRequest->hwnd,
    620                             pRequest->ulMessage,
    621                             (char*)pRequest->u1,
    622                             (char*)pRequest->u2,
    623                             (char*)pRequest->u3,
    624                             (int)  pRequest->u4);
    625       break;
    626 
    627     case WSAASYNC_GETSERVBYPORT:
    628       asyncGetServByPort   (pRequest->hwnd,
    629                             pRequest->ulMessage,
    630                             (int)  pRequest->u1,
    631                             (char*)pRequest->u2,
    632                             (char*)pRequest->u3,
    633                             (int)  pRequest->u4);
    634       break;
    635 
    636     case WSAASYNC_SELECT:
    637       break;
     882    case WSAASYNC_GETHOSTBYADDR:    asyncGetHostByAddr   (pRequest); return 1;
     883    case WSAASYNC_GETHOSTBYNAME:    asyncGetHostByName   (pRequest); return 1;
     884    case WSAASYNC_GETPROTOBYNAME:   asyncGetProtoByName  (pRequest); return 1;
     885    case WSAASYNC_GETPROTOBYNUMBER: asyncGetProtoByNumber(pRequest); return 1;
     886    case WSAASYNC_GETSERVBYNAME:    asyncGetServByName   (pRequest); return 1;
     887    case WSAASYNC_GETSERVBYPORT:    asyncGetServByPort   (pRequest); return 1;
     888
     889//    case WSAASYNC_SELECT:
     890//      break;
    638891
    639892    default:
    … …  
    643896  }
    644897
    645   pRequest->ulStatus = RS_DONE;
     898  pRequest->ulState = RS_DONE;
    646899  return 0;
    647900}
    648901
    649902
     903/*****************************************************************************
     904 * Name      :
     905 * Purpose   :
     906 * Parameters:
     907 * Variables :
     908 * Result    :
     909 * Remark    :
     910 * Status    : UNTESTED STUB
     911 *
     912 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     913 *****************************************************************************/
    650914// process all requests in queue until termination
    651915void WSAAsyncWorker::processingLoop(void)
    … …  
    662926      pRequest = popRequest();     // get request from queue
    663927      if (pRequest != NULL)
     928      {
    664929        dispatchRequest(pRequest); // process request
     930        delete pRequest;           // free the memory
     931      }
    665932    }
    666     while (pRequest != NULL)
     933    while (pRequest != NULL);
    667934
    668935    // wait for semaphore
    … …  
    676943
    677944
     945/*****************************************************************************
     946 * Name      :
     947 * Purpose   :
     948 * Parameters:
     949 * Variables :
     950 * Result    :
     951 * Remark    :
     952 * Status    : UNTESTED STUB
     953 *
     954 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     955 *****************************************************************************/
    678956// thread procedure
    679 void _System WorkerThreadProc(PVOID pParam)
     957void _Optlink WorkerThreadProc(void* pParam)
    680958{
    681959  // convert object pointer
    … …  
    685963
    686964
     965/*****************************************************************************
     966 * Name      :
     967 * Purpose   :
     968 * Parameters:
     969 * Variables :
     970 * Result    :
     971 * Remark    :
     972 * Status    : UNTESTED STUB
     973 *
     974 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     975 *****************************************************************************/
    687976// the real function calls
    688977ODINFUNCTION5(HANDLE, WSAAsyncGetHostByName, HWND,         hwnd,
    … …  
    692981                                             int,          buflen)
    693982{
    694   PASYNCREQUEST pRequest = wsaWorker->createRequest((HWND) hwnd,
     983  dprintf(("name = %s\n", name));
     984  PASYNCREQUEST pRequest = wsaWorker->createRequest(WSAASYNC_GETHOSTBYNAME,
     985                                                    (HWND) hwnd,
     986                                                    (ULONG)wMsg,
    695987                                                    (PVOID)buf,
    696988                                                    (ULONG)buflen,
    697                                                     (ULONG)wMsg,
    698989                                                    (ULONG)name);
    699990  wsaWorker->pushRequest(pRequest);
    … …  
    702993
    703994
     995/*****************************************************************************
     996 * Name      :
     997 * Purpose   :
     998 * Parameters:
     999 * Variables :
     1000 * Result    :
     1001 * Remark    :
     1002 * Status    : UNTESTED STUB
     1003 *
     1004 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     1005 *****************************************************************************/
     1006// the real function calls
     1007ODINFUNCTION7(HANDLE, WSAAsyncGetHostByAddr, HWND,         hwnd,
     1008                                             unsigned int, wMsg,
     1009                                             const char*,  addr,
     1010                                             int,          len,
     1011                                             int,          type,
     1012                                             char*,        buf,
     1013                                             int,          buflen)
     1014{
     1015  PASYNCREQUEST pRequest = wsaWorker->createRequest(WSAASYNC_GETHOSTBYADDR,
     1016                                                    (HWND) hwnd,
     1017                                                    (ULONG)wMsg,
     1018                                                    (PVOID)buf,
     1019                                                    (ULONG)buflen,
     1020                                                    (ULONG)addr,
     1021                                                    (ULONG)len,
     1022                                                    (ULONG)type);
     1023  wsaWorker->pushRequest(pRequest);
     1024  return (HANDLE)pRequest;
     1025}
     1026
     1027
     1028/*****************************************************************************
     1029 * Name      :
     1030 * Purpose   :
     1031 * Parameters:
     1032 * Variables :
     1033 * Result    :
     1034 * Remark    :
     1035 * Status    : UNTESTED STUB
     1036 *
     1037 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     1038 *****************************************************************************/
     1039// the real function calls
     1040ODINFUNCTION6(HANDLE, WSAAsyncGetServByName, HWND,         hwnd,
     1041                                             unsigned int, wMsg,
     1042                                             const char*,  name,
     1043                                             const char*,  proto,
     1044                                             char*,        buf,
     1045                                             int,          buflen)
     1046{
     1047  dprintf(("name = %s, proto = %s\n", name, proto));
     1048  PASYNCREQUEST pRequest = wsaWorker->createRequest(WSAASYNC_GETSERVBYNAME,
     1049                                                    (HWND) hwnd,
     1050                                                    (ULONG)wMsg,
     1051                                                    (PVOID)buf,
     1052                                                    (ULONG)buflen,
     1053                                                    (ULONG)name,
     1054                                                    (ULONG)proto);
     1055  wsaWorker->pushRequest(pRequest);
     1056  return (HANDLE)pRequest;
     1057}
     1058
     1059
     1060/*****************************************************************************
     1061 * Name      :
     1062 * Purpose   :
     1063 * Parameters:
     1064 * Variables :
     1065 * Result    :
     1066 * Remark    :
     1067 * Status    : UNTESTED STUB
     1068 *
     1069 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     1070 *****************************************************************************/
     1071// the real function calls
     1072ODINFUNCTION6(HANDLE, WSAAsyncGetServByPort, HWND,         hwnd,
     1073                                             unsigned int, wMsg,
     1074                                             int,          port,
     1075                                             const char*,  proto,
     1076                                             char*,        buf,
     1077                                             int,          buflen)
     1078{
     1079  dprintf(("proto = %s\n", proto));
     1080  PASYNCREQUEST pRequest = wsaWorker->createRequest(WSAASYNC_GETSERVBYPORT,
     1081                                                    (HWND) hwnd,
     1082                                                    (ULONG)wMsg,
     1083                                                    (PVOID)buf,
     1084                                                    (ULONG)buflen,
     1085                                                    (ULONG)port,
     1086                                                    (ULONG)proto);
     1087  wsaWorker->pushRequest(pRequest);
     1088  return (HANDLE)pRequest;
     1089}
     1090
     1091
     1092/*****************************************************************************
     1093 * Name      :
     1094 * Purpose   :
     1095 * Parameters:
     1096 * Variables :
     1097 * Result    :
     1098 * Remark    :
     1099 * Status    : UNTESTED STUB
     1100 *
     1101 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     1102 *****************************************************************************/
     1103// the real function calls
     1104ODINFUNCTION5(HANDLE, WSAAsyncGetProtoByName, HWND,         hwnd,
     1105                                              unsigned int, wMsg,
     1106                                              const char*,  name,
     1107                                              char*,        buf,
     1108                                              int,          buflen)
     1109{
     1110  dprintf(("name = %s\n", name));
     1111  PASYNCREQUEST pRequest = wsaWorker->createRequest(WSAASYNC_GETPROTOBYNAME,
     1112                                                    (HWND) hwnd,
     1113                                                    (ULONG)wMsg,
     1114                                                    (PVOID)buf,
     1115                                                    (ULONG)buflen,
     1116                                                    (ULONG)name);
     1117  wsaWorker->pushRequest(pRequest);
     1118  return (HANDLE)pRequest;
     1119}
     1120
     1121
     1122/*****************************************************************************
     1123 * Name      :
     1124 * Purpose   :
     1125 * Parameters:
     1126 * Variables :
     1127 * Result    :
     1128 * Remark    :
     1129 * Status    : UNTESTED STUB
     1130 *
     1131 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     1132 *****************************************************************************/
     1133// the real function calls
     1134ODINFUNCTION5(HANDLE, WSAAsyncGetProtoByNumber, HWND,         hwnd,
     1135                                              unsigned int, wMsg,
     1136                                              int,          number,
     1137                                              char*,        buf,
     1138                                              int,          buflen)
     1139{
     1140  PASYNCREQUEST pRequest = wsaWorker->createRequest(WSAASYNC_GETPROTOBYNUMBER,
     1141                                                    (HWND) hwnd,
     1142                                                    (ULONG)wMsg,
     1143                                                    (PVOID)buf,
     1144                                                    (ULONG)buflen,
     1145                                                    (ULONG)number);
     1146  wsaWorker->pushRequest(pRequest);
     1147  return (HANDLE)pRequest;
     1148}
     1149
     1150
     1151/*****************************************************************************
     1152 * Name      :
     1153 * Purpose   : cancel a queued or busy request
     1154 * Parameters:
     1155 * Variables :
     1156 * Result    :
     1157 * Remark    :
     1158 * Status    : UNTESTED STUB
     1159 *
     1160 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     1161 *****************************************************************************/
     1162
     1163ODINFUNCTION1(int, WSACancelAsyncRequest, HANDLE, hAsyncTaskHandle)
     1164{
     1165  PASYNCREQUEST pRequest = (PASYNCREQUEST)hAsyncTaskHandle;
     1166  BOOL          rc;
     1167
     1168  // remove request from queue
     1169  rc = wsaWorker->deleteRequest(pRequest);
     1170  if (rc == TRUE)
     1171    return 0; // success
     1172  else
     1173  {
     1174    WSASetLastError(WSAEINVAL);
     1175    return (SOCKET_ERROR);
     1176  }
     1177}
Note: See TracChangeset for help on using the changeset viewer.