Ignore:
Timestamp:
Oct 20, 1999, 1:04:13 PM (26 years ago)
Author:
phaller
Message:

Fix: some fixes, WSAIsBlocking

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/wsock32/async.cpp

    r1373 r1374  
    1 /* $Id: async.cpp,v 1.3 1999-10-20 10:09:49 phaller Exp $ */
     1/* $Id: async.cpp,v 1.4 1999-10-20 11:04:12 phaller Exp $ */
    22
    33/*
     
    114114class WSAAsyncWorker
    115115{
     116  // protected members
     117  protected:
     118    PASYNCREQUEST pRequestHead;        // chain root
     119    PASYNCREQUEST pRequestTail;        // chain root
     120    TID           tidWorker;           // worker thread id
     121    HEV           hevRequest;          // fired upon new request
     122    HMTX          hmtxRequestQueue;    // request queue protection
     123    BOOL          fTerminate;          // got to die ?
     124    BOOL          fBlocking;           // currently busy ?
     125
     126    TID           startWorker    (void);                   // start worker thread
     127    void          processingLoop (void);                   // "work"
     128    int           dispatchRequest(PASYNCREQUEST pRequest); // complete request
     129    PASYNCREQUEST popRequest     (void);                   // get one request from queue
     130    BOOL          deleteRequest  (PASYNCREQUEST pRequest); // remove particular request
     131
     132    void          lockQueue      (void);                   // enter mutex
     133    void          unlockQueue    (void);                   // leave mutex
     134
     135    // the real worker methods
     136    void          asyncGetHostByAddr   (PASYNCREQUEST pRequest);
     137    void          asyncGetHostByName   (PASYNCREQUEST pRequest);
     138    void          asyncGetProtoByName  (PASYNCREQUEST pRequest);
     139    void          asyncGetProtoByNumber(PASYNCREQUEST pRequest);
     140    void          asyncGetServByName   (PASYNCREQUEST pRequest);
     141    void          asyncGetServByPort   (PASYNCREQUEST pRequest);
     142
    116143  // public members
    117144  public:
     
    130157    void          pushRequest    (PASYNCREQUEST pRequest); // put request on queue
    131158    BOOL          cancelAsyncRequest   (PASYNCREQUEST pRequest);
     159    BOOL          isBlocking     (void) {return fBlocking;}
    132160
    133161    // the thread procedure
    134162    friend void _Optlink WorkerThreadProc(void* pParam);
    135 
    136 
    137   // protected members
    138   protected:
    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 ?
    145 
    146     TID           startWorker    (void);                   // start worker thread
    147     void          processingLoop (void);                   // "work"
    148     int           dispatchRequest(PASYNCREQUEST pRequest); // complete request
    149     PASYNCREQUEST popRequest     (void);                   // get one request from queue
    150     BOOL          deleteRequest  (PASYNCREQUEST pRequest); // remove particular request
    151 
    152     void          lockQueue      (void);                   // enter mutex
    153     void          unlockQueue    (void);                   // leave mutex
    154 
    155     // the real worker methods
    156     void          asyncGetHostByAddr   (PASYNCREQUEST pRequest);
    157     void          asyncGetHostByName   (PASYNCREQUEST pRequest);
    158     void          asyncGetProtoByName  (PASYNCREQUEST pRequest);
    159     void          asyncGetProtoByNumber(PASYNCREQUEST pRequest);
    160     void          asyncGetServByName   (PASYNCREQUEST pRequest);
    161     void          asyncGetServByPort   (PASYNCREQUEST pRequest);
    162163};
    163164
     
    167168 *****************************************************************************/
    168169
    169 static WSAAsyncWorker* wsaWorker = NULL;
     170//static WSAAsyncWorker* wsaWorker = NULL;
     171static WSAAsyncWorker* wsaWorker = new WSAAsyncWorker();
    170172
    171173
     
    278280#if defined(__IBMCPP__)
    279281    tidWorker = _beginthread(WorkerThreadProc,
    280                              (PVOID)this,
    281                              4096,
    282                              NULL);
     282                             NULL,
     283                             16384,
     284                             (PVOID)this);
    283285#else
    284286    tidWorker = _beginthread(WorkerThreadProc,
    285                              (PVOID)this,
    286                              4096);
     287                             16384,
     288                             (PVOID)this);
    287289#endif
    288290    if (tidWorker == -1)
     
    357359
    358360  if (pRequestTail != NULL)
     361  {
    359362    if (pRequestTail->pPrev)
    360363    {
     
    362365      pRequestTail = pRequestTail->pPrev; // unlink previous element
    363366    }
     367    else
     368    {
     369      // this is the last request on the queue
     370      pRequestTail = NULL;
     371      pRequestHead = NULL;
     372    }
     373  }
    364374
    365375  unlockQueue();  // unlock queue
     
    905915int WSAAsyncWorker::dispatchRequest(PASYNCREQUEST pRequest)
    906916{
     917  int rc;
     918
    907919  dprintf(("WSOCK32-ASYNC: WSAAsyncWorker::dispatchRequest (%08xh, %08xh)\n",
    908920           this,
     
    927939  // OK, servicing request
    928940  pRequest->ulState = RS_BUSY;
     941  fBlocking         = TRUE;
    929942
    930943  switch(pRequest->ulType)
     
    934947      return 1;
    935948
    936     case WSAASYNC_GETHOSTBYADDR:    asyncGetHostByAddr   (pRequest); return 1;
    937     case WSAASYNC_GETHOSTBYNAME:    asyncGetHostByName   (pRequest); return 1;
    938     case WSAASYNC_GETPROTOBYNAME:   asyncGetProtoByName  (pRequest); return 1;
    939     case WSAASYNC_GETPROTOBYNUMBER: asyncGetProtoByNumber(pRequest); return 1;
    940     case WSAASYNC_GETSERVBYNAME:    asyncGetServByName   (pRequest); return 1;
    941     case WSAASYNC_GETSERVBYPORT:    asyncGetServByPort   (pRequest); return 1;
     949    case WSAASYNC_GETHOSTBYADDR:    asyncGetHostByAddr   (pRequest); rc = 1; break;
     950    case WSAASYNC_GETHOSTBYNAME:    asyncGetHostByName   (pRequest); rc = 1; break;
     951    case WSAASYNC_GETPROTOBYNAME:   asyncGetProtoByName  (pRequest); rc = 1; break;
     952    case WSAASYNC_GETPROTOBYNUMBER: asyncGetProtoByNumber(pRequest); rc = 1; break;
     953    case WSAASYNC_GETSERVBYNAME:    asyncGetServByName   (pRequest); rc = 1; break;
     954    case WSAASYNC_GETSERVBYPORT:    asyncGetServByPort   (pRequest); rc = 1; break;
    942955
    943956//    case WSAASYNC_SELECT:
     
    947960      dprintf(("WSOCK32: WSAAsyncWorker::dispatchRequest - invalid request type %d\n",
    948961                pRequest->ulType));
    949       return 1;
     962      rc = 1; break;
    950963  }
    951964
    952965  pRequest->ulState = RS_DONE;
    953   return 0;
     966  fBlocking         = FALSE;
     967  return rc;
    954968}
    955969
     
    12301244  }
    12311245}
     1246
     1247
     1248/*****************************************************************************
     1249 * Name      : WSAIsBlocking
     1250 * Purpose   :
     1251 * Parameters:
     1252 * Variables :
     1253 * Result    :
     1254 * Remark    :
     1255 * Status    : UNTESTED STUB
     1256 *
     1257 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     1258 *****************************************************************************/
     1259
     1260ODINFUNCTION0(BOOL, WSAIsBlocking)
     1261{
     1262  return(wsaWorker->isBlocking());
     1263}
Note: See TracChangeset for help on using the changeset viewer.