Ignore:
Timestamp:
Nov 19, 2005 1:19:28 PM (18 years ago)
Author:
bennylp
Message:

Added PJ_IOQUEUE_ALWAYS_ASYNC flag

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjlib/src/pj/ioqueue_common_abs.c

    r51 r55  
    492492                                      unsigned flags ) 
    493493{ 
    494     pj_status_t status; 
    495     pj_ssize_t size; 
    496494    struct read_operation *read_op; 
    497495 
     
    504502    /* Try to see if there's data immediately available.  
    505503     */ 
    506     size = *length; 
    507     status = pj_sock_recv(key->fd, buffer, &size, flags); 
    508     if (status == PJ_SUCCESS) { 
    509         /* Yes! Data is available! */ 
    510         *length = size; 
    511         return PJ_SUCCESS; 
    512     } else { 
    513         /* If error is not EWOULDBLOCK (or EAGAIN on Linux), report 
    514          * the error to caller. 
    515          */ 
    516         if (status != PJ_STATUS_FROM_OS(PJ_BLOCKING_ERROR_VAL)) 
    517             return status; 
    518     } 
     504    if ((flags & PJ_IOQUEUE_ALWAYS_ASYNC) == 0) { 
     505        pj_status_t status; 
     506        pj_ssize_t size; 
     507 
     508        size = *length; 
     509        status = pj_sock_recv(key->fd, buffer, &size, flags); 
     510        if (status == PJ_SUCCESS) { 
     511            /* Yes! Data is available! */ 
     512            *length = size; 
     513            return PJ_SUCCESS; 
     514        } else { 
     515            /* If error is not EWOULDBLOCK (or EAGAIN on Linux), report 
     516             * the error to caller. 
     517             */ 
     518            if (status != PJ_STATUS_FROM_OS(PJ_BLOCKING_ERROR_VAL)) 
     519                return status; 
     520        } 
     521    } 
     522 
     523    flags &= ~(PJ_IOQUEUE_ALWAYS_ASYNC); 
    519524 
    520525    /* 
     
    548553                                         int *addrlen) 
    549554{ 
    550     pj_status_t status; 
    551     pj_ssize_t size; 
    552555    struct read_operation *read_op; 
    553556 
     
    560563    /* Try to see if there's data immediately available.  
    561564     */ 
    562     size = *length; 
    563     status = pj_sock_recvfrom(key->fd, buffer, &size, flags, 
    564                               addr, addrlen); 
    565     if (status == PJ_SUCCESS) { 
    566         /* Yes! Data is available! */ 
    567         *length = size; 
    568         return PJ_SUCCESS; 
    569     } else { 
    570         /* If error is not EWOULDBLOCK (or EAGAIN on Linux), report 
    571          * the error to caller. 
    572          */ 
    573         if (status != PJ_STATUS_FROM_OS(PJ_BLOCKING_ERROR_VAL)) 
    574             return status; 
    575     } 
     565    if ((flags & PJ_IOQUEUE_ALWAYS_ASYNC) == 0) { 
     566        pj_status_t status; 
     567        pj_ssize_t size; 
     568 
     569        size = *length; 
     570        status = pj_sock_recvfrom(key->fd, buffer, &size, flags, 
     571                                  addr, addrlen); 
     572        if (status == PJ_SUCCESS) { 
     573            /* Yes! Data is available! */ 
     574            *length = size; 
     575            return PJ_SUCCESS; 
     576        } else { 
     577            /* If error is not EWOULDBLOCK (or EAGAIN on Linux), report 
     578             * the error to caller. 
     579             */ 
     580            if (status != PJ_STATUS_FROM_OS(PJ_BLOCKING_ERROR_VAL)) 
     581                return status; 
     582        } 
     583    } 
     584 
     585    flags &= ~(PJ_IOQUEUE_ALWAYS_ASYNC); 
    576586 
    577587    /* 
     
    614624    write_op = (struct write_operation*)op_key; 
    615625    write_op->op = 0; 
     626 
     627    /* We can not use PJ_IOQUEUE_ALWAYS_ASYNC for socket write. */ 
     628    flags &= ~(PJ_IOQUEUE_ALWAYS_ASYNC); 
    616629 
    617630    /* Fast track: 
     
    676689                                       const void *data, 
    677690                                       pj_ssize_t *length, 
    678                                        unsigned flags, 
     691                                       pj_uint32_t flags, 
    679692                                       const pj_sockaddr_t *addr, 
    680693                                       int addrlen) 
     
    689702    write_op = (struct write_operation*)op_key; 
    690703    write_op->op = 0; 
     704 
     705    /* We can not use PJ_IOQUEUE_ALWAYS_ASYNC for socket write */ 
     706    flags &= ~(PJ_IOQUEUE_ALWAYS_ASYNC); 
    691707 
    692708    /* Fast track: 
Note: See TracChangeset for help on using the changeset viewer.