Changeset 4873:98d17d4deeec in roaraudio


Ignore:
Timestamp:
04/26/11 11:03:46 (12 years ago)
Author:
phi
Branch:
default
Phase:
public
Message:

make use of new error stuff

Files:
8 edited

Legend:

Unmodified
Added
Removed

  • include/libroar/error.h

    r4872 r4873  
    7171int    roar_err_parsemsg(struct roar_message * mes, struct roar_error_frame * frame); 
    7272 
     73#define roar_error (*roar_errno2()) 
    7374int *  roar_errno2(void); 
    7475 

  • libroar/basic.c

    r4806 r4873  
    6363 int workarounds_store; 
    6464 
    65  roar_errno = ROAR_ERROR_UNKNOWN; 
     65 roar_err_set(ROAR_ERROR_UNKNOWN); 
    6666 
    6767 if ( timeout != 0 ) { 
    68   roar_errno = ROAR_ERROR_INVAL; 
     68  roar_err_set(ROAR_ERROR_INVAL); 
    6969  return -1; 
    7070 } 
    … …  
    231231 
    232232 if ( fh == -1 ) 
    233   roar_errno = ROAR_ERROR_CONNREFUSED; 
     233  roar_err_set(ROAR_ERROR_CONNREFUSED); 
    234234 
    235235 ROAR_DBG("roar_connect_raw(*) = %i", fh); 
    … …  
    246246 
    247247 if ( con == NULL ) { 
    248   roar_errno = ROAR_ERROR_INVAL; 
    249   return -1; 
    250  } 
    251  
    252  roar_errno = ROAR_ERROR_UNKNOWN; 
     248  roar_err_set(ROAR_ERROR_FAULT); 
     249  return -1; 
     250 } 
     251 
     252 roar_err_set(ROAR_ERROR_UNKNOWN); 
    253253 fh = roar_connect_raw2(server, flags, timeout); 
    254254 
    … …  
    262262 
    263263 if ( con == NULL || fh == -1 ) { 
    264   roar_errno = ROAR_ERROR_INVAL; 
     264  roar_err_set(ROAR_ERROR_INVAL); 
    265265  return -1; 
    266266 } 
    … …  
    278278  con->flags |= ROAR_CON_FLAGS_VIO; 
    279279 
    280  roar_errno = ROAR_ERROR_NONE; 
     280 roar_err_set(ROAR_ERROR_NONE); 
    281281 return 0; 
    282282} 
    … …  
    337337 roar_connect_fh(con, -2); 
    338338 
    339  roar_errno = ROAR_ERROR_NONE; 
     339 roar_err_set(ROAR_ERROR_NONE); 
    340340 
    341341 return 0; 
    … …  
    384384 int max_len; 
    385385 
    386  roar_errno = ROAR_ERROR_UNKNOWN; 
     386 roar_err_set(ROAR_ERROR_UNKNOWN); 
    387387 
    388388 ROAR_DBG("roar_identify(*): try to identify myself..."); 

  • libroar/ctl.c

    r4740 r4873  
    194194 m.data[0] = id; 
    195195 
    196  roar_errno = ROAR_ERROR_UNKNOWN; 
     196 roar_err_set(ROAR_ERROR_UNKNOWN); 
    197197 
    198198 if ( roar_req(con, &m, NULL) == -1 ) { 
    199   roar_errno = ROAR_ERROR_PROTO; 
     199  roar_err_set(ROAR_ERROR_PROTO); 
    200200  return -1; 
    201201 } 

  • libroar/ltm.c

    r4708 r4873  
    6666 
    6767 if ( mt == 0 || streams == NULL || slen == 0 || mes == NULL || buf == NULL ) { 
    68   roar_errno = ROAR_ERROR_INVAL; 
     68  roar_err_set(ROAR_ERROR_INVAL); 
    6969  return -1; 
    7070 } 
    … …  
    8181   break; 
    8282  default: 
    83     roar_errno = ROAR_ERROR_NOTSUP; 
     83    roar_err_set(ROAR_ERROR_NOTSUP); 
    8484    return -1; 
    8585   break; 
    … …  
    9595 
    9696 if ( mes->datalen > LIBROAR_BUFFER_MSGDATA ) { 
    97   roar_errno = ROAR_ERROR_NOTSUP; 
     97  roar_err_set(ROAR_ERROR_NOTSUP); 
    9898  return -1; 
    9999 } 

  • libroar/notify.c

    r4708 r4873  
    6060static struct roar_notify_core * _libroar_notify_core = NULL; 
    6161 
    62 #define _CKRCORE(ret) if ( core == NULL ) { if ( _libroar_notify_core == NULL ) { roar_errno = ROAR_ERROR_INVAL; return (ret); } else { core = _libroar_notify_core; } } 
     62#define _CKRCORE(ret) if ( core == NULL ) { if ( _libroar_notify_core == NULL ) { roar_err_set(ROAR_ERROR_INVAL); return (ret); } else { core = _libroar_notify_core; } } 
    6363#define _CKICORE() _CKRCORE(-1) 
    6464 
    … …  
    9797   break; 
    9898  default: 
    99     roar_errno = ROAR_ERROR_INVAL; 
     99    roar_err_set(ROAR_ERROR_INVAL); 
    100100    return NULL; 
    101101   break; 
    … …  
    172172int roar_notify_core_new_global(ssize_t lists) { 
    173173 if ( _libroar_notify_core != NULL ) { 
    174   roar_errno = ROAR_ERROR_INVAL; 
     174  roar_err_set(ROAR_ERROR_INVAL); 
    175175  return -1; 
    176176 } 
    … …  
    202202 if ( event == NULL || cb == NULL ) { 
    203203  ROAR_DBG("roar_notify_core_subscribe(core=%p, event=%p, cb=%p, userdata=%p) = NULL // errno = EINVAL", core, event, cb, userdata); 
    204   roar_errno = ROAR_ERROR_INVAL; 
     204  roar_err_set(ROAR_ERROR_FAULT); 
    205205  return NULL; 
    206206 } 
    … …  
    246246 
    247247 if ( subscriber == NULL ) { 
    248   roar_errno = ROAR_ERROR_INVAL; 
     248  roar_err_set(ROAR_ERROR_FAULT); 
    249249  return -1; 
    250250 } 
    … …  
    275275 
    276276 if ( event == NULL ) { 
    277   roar_errno = ROAR_ERROR_INVAL; 
     277  roar_err_set(ROAR_ERROR_FAULT); 
    278278  return -1; 
    279279 } 

  • libroar/proto.c

    r4708 r4873  
    6565 char * bufptr; 
    6666 
    67  roar_errno = ROAR_ERROR_UNKNOWN; 
     67 roar_err_set(ROAR_ERROR_UNKNOWN); 
    6868 
    6969 ROAR_DBG("roar_send_message(*): try to send an request..."); 
    … …  
    8787    buf[2]              = (unsigned char)  mes->cmd; 
    8888    // ... 
    89     roar_errno = ROAR_ERROR_NOTSUP; 
     89    roar_err_set(ROAR_ERROR_NOTSUP); 
    9090    return -1; 
    9191   break; 
    … …  
    107107   break; 
    108108  default: 
    109     roar_errno = ROAR_ERROR_NOTSUP; 
     109    roar_err_set(ROAR_ERROR_NOTSUP); 
    110110    return -1; 
    111111 } 
    112112 
    113113 if ( roar_vio_write(vio, buf, headerlen) != headerlen ) { 
    114   roar_errno = ROAR_ERROR_PIPE; 
    115114  return -1; 
    116115 } 
    … …  
    118117 if ( mes->datalen != 0 ) { 
    119118  if ( roar_vio_write(vio, data == NULL ? mes->data : data, mes->datalen) != mes->datalen ) { 
    120    roar_errno = ROAR_ERROR_PIPE; 
    121119   return -1; 
    122120  } 
    … …  
    125123 if ( crclen != 0 ) { 
    126124  if ( roar_vio_write(vio, crc, crclen) != crclen ) { 
    127    roar_errno = ROAR_ERROR_PIPE; 
    128    return -1; 
    129   } 
    130  } 
    131  
    132  roar_errno = ROAR_ERROR_NONE; 
     125   return -1; 
     126  } 
     127 } 
     128 
     129 roar_err_clear(); 
    133130 
    134131 ROAR_DBG("roar_send_message(*) = 0"); 
    … …  
    154151 char * bufptr; 
    155152 
    156  roar_errno = ROAR_ERROR_UNKNOWN; 
     153 roar_err_set(ROAR_ERROR_UNKNOWN); 
    157154 
    158155 ROAR_DBG("roar_recv_message(*): try to get a response form the server..."); 
    … …  
    167164 
    168165 if ( roar_vio_read(vio, buf, _ROAR_MESS_BUF_LEN_V0) != _ROAR_MESS_BUF_LEN_V0 ) { 
    169   roar_errno = ROAR_ERROR_PROTO; 
     166  roar_err_set(ROAR_ERROR_PROTO); 
    170167  return -1; 
    171168 } 
    … …  
    195192   break; 
    196193  default: 
    197     roar_errno = ROAR_ERROR_PROTO; 
     194    roar_err_set(ROAR_ERROR_PROTO); 
    198195    return -1; 
    199196   break; 
    … …  
    205202  needlen = headerlen - _ROAR_MESS_BUF_LEN_V0; 
    206203  if ( roar_vio_read(vio, buf+_ROAR_MESS_BUF_LEN_V0, needlen) != (ssize_t)needlen ) { 
    207    roar_errno = ROAR_ERROR_PROTO; 
     204   roar_err_set(ROAR_ERROR_PROTO); 
    208205   return -1; 
    209206  } 
    … …  
    235232  ROAR_DBG("roar_recv_message(*): no data in this pkg"); 
    236233  ROAR_DBG("roar_recv_message(*) = 0"); 
    237   roar_errno = ROAR_ERROR_NONE; 
     234  roar_err_clear(); 
    238235  return 0; 
    239236 } 
    … …  
    243240   ROAR_DBG("roar_recv_message(*): Got data!"); 
    244241   ROAR_DBG("roar_recv_message(*) = 0"); 
    245    roar_errno = ROAR_ERROR_NONE; 
     242   roar_err_clear(); 
    246243   return 0; 
    247244  } 
    248245 
    249   roar_errno = ROAR_ERROR_PIPE; 
    250246  return -1; 
    251247 } else { 
    252248  if ( data == NULL ) { 
    253    roar_errno = ROAR_ERROR_MSGSIZE; 
     249   roar_err_set(ROAR_ERROR_MSGSIZE); 
    254250   return -1; 
    255251  } 
    256252 
    257253  if ( (*data = malloc(mes->datalen)) == NULL ) { 
    258    roar_errno = ROAR_ERROR_NOMEM; 
     254   roar_err_set(ROAR_ERROR_NOMEM); 
    259255   return -1; 
    260256  } 
    261257 
    262258  if ( mes->datalen == 0 ) { 
    263    roar_errno = ROAR_ERROR_NONE; 
     259   roar_err_clear(); 
    264260   return 0; 
    265261  } 
    … …  
    268264   ROAR_DBG("roar_recv_message(*): Got data!"); 
    269265   ROAR_DBG("roar_recv_message(*) = 0"); 
    270    roar_errno = ROAR_ERROR_NONE; 
     266   roar_err_clear(); 
    271267   return 0; 
    272268  } 
    273269 
    274   roar_errno = ROAR_ERROR_PIPE; 
     270  roar_err_set(ROAR_ERROR_PIPE); 
    275271  return -1; 
    276272 } 

  • libroar/vio.c

    r4831 r4873  
    4646int roar_vio_init_calls (struct roar_vio_calls * calls) { 
    4747#ifdef _CAN_OPERATE 
    48  if ( calls == NULL ) 
    49   return -1; 
     48 if ( calls == NULL ) { 
     49  roar_err_set(ROAR_ERROR_FAULT); 
     50  return -1; 
     51 } 
    5052 
    5153 memset((void*)calls, 0, sizeof(struct roar_vio_calls)); 
    … …  
    7274 
    7375int roar_vio_set_inst (struct roar_vio_calls * vio, void * inst) { 
    74  if ( vio == NULL ) 
    75   return -1; 
     76 if ( vio == NULL ) { 
     77  roar_err_set(ROAR_ERROR_FAULT); 
     78  return -1; 
     79 } 
    7680 
    7781 vio->inst = inst; 
    … …  
    8589 
    8690int roar_vio_get_fh   (struct roar_vio_calls * vio) { 
    87  if ( vio == NULL ) 
    88   return -1; 
     91 if ( vio == NULL ) { 
     92  roar_err_set(ROAR_ERROR_FAULT); 
     93  return -1; 
     94 } 
    8995 
    9096 return ((int)(ROAR_INSTINT)vio->inst) - 1; 
    … …  
    9399 
    94100ssize_t roar_vio_read (struct roar_vio_calls * vio, void *buf, size_t count) { 
     101 ssize_t ret; 
     102 
    95103 ROAR_DBG("roar_vio_read(vio=%p, buf=%p, count=%u) = ?", vio, buf, (unsigned int)count); 
    96104 
    97  if ( vio == NULL ) 
    98   return -1; 
    99  
    100  if ( vio->read == NULL ) 
    101   return -1; 
    102  
    103  return vio->read(vio, buf, count); 
     105 if ( vio == NULL ) { 
     106  roar_err_set(ROAR_ERROR_FAULT); 
     107  return -1; 
     108 } 
     109 
     110 if ( vio->read == NULL ) { 
     111  roar_err_set(ROAR_ERROR_NOSYS); 
     112  return -1; 
     113 } 
     114 
     115 roar_err_clear_all(); 
     116 ret = vio->read(vio, buf, count); 
     117 roar_err_update(); 
     118 
     119 return ret; 
    104120} 
    105121 
    106122ssize_t roar_vio_write(struct roar_vio_calls * vio, void *buf, size_t count) { 
     123 ssize_t ret; 
     124 
    107125 ROAR_DBG("roar_vio_write(vio=%p, buf=%p, count=%u) = ?", vio, buf, (unsigned int)count); 
    108126 
    109  if ( vio == NULL ) 
    110   return -1; 
    111  
    112  if ( vio->write == NULL ) 
    113   return -1; 
    114  
    115  return vio->write(vio, buf, count); 
     127 if ( vio == NULL ) { 
     128  roar_err_set(ROAR_ERROR_FAULT); 
     129  return -1; 
     130 } 
     131 
     132 if ( vio->write == NULL ) { 
     133  roar_err_set(ROAR_ERROR_NOSYS); 
     134  return -1; 
     135 } 
     136 
     137 roar_err_clear_all(); 
     138 ret = vio->write(vio, buf, count); 
     139 roar_err_update(); 
     140 
     141 return ret; 
    116142} 
    117143 
    118144off_t   roar_vio_lseek(struct roar_vio_calls * vio, off_t offset, int whence) { 
     145 off_t ret; 
     146 
    119147 ROAR_DBG("roar_vio_lseek(vio=%p, offset=%u, whence=%i) = ?", vio, (unsigned int)offset, whence); 
    120148 
    121  if ( vio == NULL ) 
    122   return -1; 
    123  
    124  if ( vio->lseek == NULL ) 
    125   return -1; 
    126  
    127  return vio->lseek(vio, offset, whence); 
     149 if ( vio == NULL ) { 
     150  roar_err_set(ROAR_ERROR_FAULT); 
     151  return -1; 
     152 } 
     153 
     154 if ( vio->lseek == NULL ) { 
     155  roar_err_set(ROAR_ERROR_NOSYS); 
     156  return -1; 
     157 } 
     158 
     159 roar_err_clear_all(); 
     160 ret = vio->lseek(vio, offset, whence); 
     161 roar_err_update(); 
     162 
     163 return ret; 
    128164} 
    129165 
    130166int     roar_vio_nonblock(struct roar_vio_calls * vio, int state) { 
     167 int ret; 
     168 
    131169 ROAR_DBG("roar_vio_nonblock(vio=%p, state=%i) = ?", vio, state); 
    132170 
    133  if ( vio == NULL ) 
    134   return -1; 
    135  
    136  if ( vio->nonblock == NULL ) 
    137   return -1; 
    138  
    139  return vio->nonblock(vio, state); 
     171 if ( vio == NULL ) { 
     172  roar_err_set(ROAR_ERROR_FAULT); 
     173  return -1; 
     174 } 
     175 
     176 if ( vio->nonblock == NULL ) { 
     177  roar_err_set(ROAR_ERROR_NOSYS); 
     178  return -1; 
     179 } 
     180 
     181 roar_err_clear_all(); 
     182 ret = vio->nonblock(vio, state); 
     183 roar_err_update(); 
     184 
     185 return ret; 
    140186} 
    141187 
    142188int     roar_vio_sync    (struct roar_vio_calls * vio) { 
     189 int ret; 
     190 
    143191 ROAR_DBG("roar_vio_sync(vio=%p) = ?", vio); 
    144192 
    145  if ( vio == NULL ) 
    146   return -1; 
    147  
    148  if ( vio->sync == NULL ) 
    149   return -1; 
    150  
    151  return vio->sync(vio); 
     193 if ( vio == NULL ) { 
     194  roar_err_set(ROAR_ERROR_FAULT); 
     195  return -1; 
     196 } 
     197 
     198 if ( vio->sync == NULL ) { 
     199  roar_err_set(ROAR_ERROR_NOSYS); 
     200  return -1; 
     201 } 
     202 
     203 roar_err_clear_all(); 
     204 ret = vio->sync(vio); 
     205 roar_err_update(); 
     206 
     207 return ret; 
    152208} 
    153209 
    154210int     roar_vio_ctl     (struct roar_vio_calls * vio, int cmd, void * data) { 
     211 int ret; 
     212 
    155213 ROAR_DBG("roar_vio_ctl(vio=%p, cmd=%i, data=%p) = ?", vio, cmd, data); 
    156214 
    157  if ( vio == NULL ) 
    158   return -1; 
     215 if ( vio == NULL ) { 
     216  roar_err_set(ROAR_ERROR_FAULT); 
     217  return -1; 
     218 } 
    159219 
    160220 ROAR_DBG("roar_vio_ctl(vio=%p, cmd=0x%.8x, data=%p): vio->ctl=%p", vio, cmd, data, vio->ctl); 
    … …  
    166226    ROAR_ERR("roar_vio_ctl(vio=%p, cmd=0x%.8x, data=%p): Please recompile your program to fix this. (No additional steps are required beside that.)", vio, cmd, data); 
    167227    ROAR_DBG("roar_vio_ctl(vio=%p, cmd=0x%.8x, data=%p) = -1", vio, cmd, data); 
     228    roar_err_set(ROAR_ERROR_BADRQC); 
    168229    return -1; 
    169230   break; 
    170231 } 
    171232 
    172  if ( vio->ctl == NULL ) 
    173   return -1; 
    174  
    175  return vio->ctl(vio, cmd, data); 
     233 if ( vio->ctl == NULL ) { 
     234  roar_err_set(ROAR_ERROR_NOSYS); 
     235  return -1; 
     236 } 
     237 
     238 roar_err_clear_all(); 
     239 ret = vio->ctl(vio, cmd, data); 
     240 roar_err_update(); 
     241 
     242 return ret; 
    176243} 
    177244 
    178245int     roar_vio_close    (struct roar_vio_calls * vio) { 
     246 int ret; 
     247 
    179248 ROAR_DBG("roar_vio_close(vio=%p) = ?", vio); 
    180249 
    181  if ( vio == NULL ) 
    182   return -1; 
    183  
    184  if ( vio->close == NULL ) 
    185   return -1; 
    186  
    187  return vio->close(vio); 
     250 if ( vio == NULL ) { 
     251  roar_err_set(ROAR_ERROR_FAULT); 
     252  return -1; 
     253 } 
     254 
     255 if ( vio->close == NULL ) { 
     256  roar_err_set(ROAR_ERROR_NOSYS); 
     257  return -1; 
     258 } 
     259 
     260 roar_err_clear_all(); 
     261 ret = vio->close(vio); 
     262 roar_err_update(); 
     263 
     264 return ret; 
    188265} 
    189266 
    190267// specal commands: 
    191268int     roar_vio_accept  (struct roar_vio_calls * calls, struct roar_vio_calls * dst) { 
    192  if (dst == NULL || calls == NULL) 
    193   return -1; 
     269 if (dst == NULL || calls == NULL) { 
     270  roar_err_set(ROAR_ERROR_FAULT); 
     271  return -1; 
     272 } 
    194273 
    195274 return roar_vio_ctl(dst, ROAR_VIO_CTL_ACCEPT, calls); 
    … …  
    205284 int fh; 
    206285 
    207  if ( calls == NULL || filename == NULL ) 
    208   return -1; 
     286 roar_debug_warn_obsolete("roar_vio_open_file", "roar_vio_open_dstr", NULL); 
     287 
     288 if ( calls == NULL || filename == NULL ) { 
     289  roar_err_set(ROAR_ERROR_FAULT); 
     290  return -1; 
     291 } 
    209292 
    210293#ifdef ROAR_TARGET_WIN32 
    … …  
    212295#endif 
    213296 
    214  if ( (fh = open(filename, flags, mode)) == -1 ) 
    215   return -1; 
     297 roar_err_clear_all(); 
     298 if ( (fh = open(filename, flags, mode)) == -1 ) { 
     299  roar_err_update(); 
     300  return -1; 
     301 } 
    216302 
    217303 if ( roar_vio_open_fh(calls, fh) == -1 ) { 
    218304  close(fh); 
    219   return -1; 
    220  } 
    221  
     305  roar_err_update(); 
     306  return -1; 
     307 } 
     308 
     309 roar_err_update(); 
    222310 return 0; 
    223311#else 
    … …  
    584672 } 
    585673 
     674 roar_err_set(ROAR_ERROR_BADRQC); 
    586675 return -1; 
    587676} 
    … …  
    708797  return -1; 
    709798 
    710  errno = 0; 
     799 roar_err_clear_all(); 
    711800 
    712801 while ( (r = roar_vio_read((struct roar_vio_calls *) vio->inst, buf, count)) > 0 ) { 
    … …  
    734823  return -1; 
    735824 
    736  errno = 0; 
     825 roar_err_clear_all(); 
    737826 
    738827 while ( (r = roar_vio_write((struct roar_vio_calls *) vio->inst, buf, count)) > 0 ) { 

  • libroar/vs.c

    r4850 r4873  
    4949#define FLAG_DIR_OUT   0x2000 
    5050 
    51 #define _initerr()  do { errno = 0; roar_err_clear(); } while(0) 
    52 #define _seterr(x)  do { if ( error != NULL ) *error = (x); ROAR_DBG("roar_vs_*(*): *error=%s(%i)", roar_vs_strerr((x)), (x)); } while(0) 
    53 #define _seterrre() do { _seterr(roar_errno); } while(0) 
    54 #define _seterrse() do { roar_err_from_errno(); _seterr(roar_errno); } while(0) 
     51#define _initerr()  roar_err_clear_all() 
     52#define _seterr(x)  do { if ( error != NULL ) *error = (x); roar_err_set((x)); ROAR_DBG("roar_vs_*(*): *error=%s(%i)", roar_vs_strerr((x)), (x)); } while(0) 
     53#define _seterrre() do { _seterr(roar_error); } while(0) 
     54#define _seterrse() do { roar_err_from_errno(); _seterr(roar_error); } while(0) 
    5555#define _ckvss(ret) do { if ( vss == NULL ) { _seterr(ROAR_ERROR_INVAL); return (ret); } } while(0) 
    5656 
    … …  
    405405 if ( ret == -1 ) { 
    406406#ifdef EAGAIN 
    407   if ( errno == EAGAIN ) 
    408    return 0; 
    409 #endif 
    410  
    411 #ifdef EWOULDBLOCK 
    412   if ( errno == EWOULDBLOCK ) 
     407  if ( roar_error == ROAR_ERROR_AGAIN ) 
    413408   return 0; 
    414409#endif 
Note: See TracChangeset for help on using the changeset viewer.