Changeset 5145:c1a3ca765154 in roaraudio for libroar


Ignore:
Timestamp:
10/11/11 13:47:59 (12 years ago)
Author:
phi
Branch:
default
Phase:
public
Message:
  • Fixed invalid pointer aliasing in filter code (pr0)
  • Fixed remote a local buffer overflow in client to message converter code as well as a remote attackable overflow in message to client converter code (pr0)
  • Updated error handling (pr0)
Location:
libroar
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • libroar/beep.c

    r4708 r5145  
    4040 int16_t * data = (int16_t*)m.data; 
    4141 
    42  if ( con == NULL ) 
     42 if ( con == NULL ) { 
     43  roar_err_set(ROAR_ERROR_FAULT); 
    4344  return -1; 
     45 } 
    4446 
    4547 memset(&m, 0, sizeof(m)); 
  • libroar/client.c

    r4948 r5145  
    3939 int i; 
    4040 
    41  if ( client == NULL ) 
     41 if ( client == NULL ) { 
     42  roar_err_set(ROAR_ERROR_FAULT); 
    4243  return -1; 
     44 } 
    4345 
    4446 memset(client, 0, sizeof(struct roar_client)); 
     
    5860 
    5961int roar_client_set_fh   (struct roar_client * client, int fh) { 
    60  if ( client == NULL ) 
     62 if ( client == NULL ) { 
     63  roar_err_set(ROAR_ERROR_FAULT); 
    6164  return -1; 
     65 } 
    6266 
    6367 client->fh = fh; 
     
    6771 
    6872int roar_client_set_proto(struct roar_client * client, int proto, int byteorder) { 
    69  if ( client == NULL ) 
     73 if ( client == NULL ) { 
     74  roar_err_set(ROAR_ERROR_FAULT); 
    7075  return -1; 
     76 } 
    7177 
    7278 client->proto = proto; 
     
    8086    break; 
    8187   default: 
     88     roar_err_set(ROAR_ERROR_INVAL); 
    8289     return -1; 
    8390    break; 
     
    93100 int confh; 
    94101 int i; 
     102 
     103 if ( con == NULL || client == NULL ) { 
     104  roar_err_set(ROAR_ERROR_FAULT); 
     105  return -1; 
     106 } 
    95107 
    96108 memset(&m,  0, sizeof(m)); 
     
    133145 int i; 
    134146 
     147 if ( con == NULL || client == NULL ) { 
     148  roar_err_set(ROAR_ERROR_FAULT); 
     149  return -1; 
     150 } 
     151 
    135152 memset(&m,  0, sizeof(m)); 
    136153 
  • libroar/ctl.c

    r5144 r5145  
    311311 m->data[1] = filter; 
    312312 m->data[2] = cmp; 
    313  *((uint32_t*)&(m->data[3])) = ROAR_HOST2NET32(id); 
     313 m->data[3] = (id & 0xFF000000LU) >> 24; 
     314 m->data[4] = (id & 0x00FF0000LU) >> 16; 
     315 m->data[5] = (id & 0x0000FF00LU) >>  8; 
     316 m->data[6] = (id & 0x000000FFLU) >>  0; 
    314317 
    315318 return 0; 
    316319} 
    317320int roar_ctl_m2f      (struct roar_message * m, unsigned char * filter, unsigned char * cmp, uint32_t * id) { 
     321 register uint32_t idreg; 
    318322 
    319323 if ( m->datalen != 7 ) 
     
    328332 *cmp    = m->data[2]; 
    329333 
    330  *id = ROAR_NET2HOST32(*((uint32_t*)&(m->data[3]))); 
     334 idreg   = ((uint32_t)(unsigned char)m->data[3]) << 24; 
     335 idreg  |= ((uint32_t)(unsigned char)m->data[4]) << 16; 
     336 idreg  |= ((uint32_t)(unsigned char)m->data[5]) <<  8; 
     337 idreg  |= ((uint32_t)(unsigned char)m->data[6]) <<  0; 
     338 *id     = idreg; 
    331339 
    332340 return 0; 
     
    345353   break; 
    346354  default: 
     355    roar_err_set(ROAR_ERROR_NOTSUP); 
    347356    return -1; 
    348357 } 
     
    352361 int i; 
    353362 
    354  if ( len > LIBROAR_BUFFER_MSGDATA ) 
    355   return -1; 
     363 if ( len > LIBROAR_BUFFER_MSGDATA ) { 
     364  roar_err_set(ROAR_ERROR_MSGSIZE); 
     365  return -1; 
     366 } 
    356367 
    357368 m->datalen = len; 
     
    365376 int i; 
    366377 
    367  if ( m->datalen > len ) 
    368   return -1; 
     378 if ( m->datalen > len ) { 
     379  roar_err_set(ROAR_ERROR_MSGSIZE); 
     380  return -1; 
     381 } 
    369382 
    370383 for (i = 0; i < m->datalen; i++) 
     
    380393 int max_len; 
    381394 uint32_t pid; 
    382  size_t len_rest; 
     395 signed long int len_rest; 
     396 size_t nnode_len; 
    383397 
    384398 if ( c == NULL ) 
     
    429443 cur += 4; 
    430444 
    431  len_rest = sizeof(m->data) - cur; 
    432  if ( roar_nnode_to_blob(&(c->nnode), &(m->data[cur]), &len_rest) == 0 ) { 
    433   cur += len_rest; 
     445 len_rest = (long int)sizeof(m->data) - (long int)cur; 
     446 if ( len_rest < 0 ) { 
     447  roar_panic(ROAR_FATAL_ERROR_MEMORY_CORRUPTION, NULL); 
     448 } 
     449 
     450 nnode_len = len_rest; 
     451 if ( roar_nnode_to_blob(&(c->nnode), &(m->data[cur]), &nnode_len) == 0 ) { 
     452  cur += nnode_len; 
    434453 } 
    435454 
     
    445464 size_t len; 
    446465 
    447  if ( m == NULL || c == NULL ) 
    448   return -1; 
    449  
    450  if ( m->datalen == 0 ) 
    451   return -1; 
     466 if ( m == NULL || c == NULL ) { 
     467  roar_err_set(ROAR_ERROR_FAULT); 
     468  return -1; 
     469 } 
     470 
     471 if ( m->datalen == 0 ) { 
     472  roar_err_set(ROAR_ERROR_MSGSIZE); 
     473  return -1; 
     474 } 
    452475 
    453476 ROAR_DBG("roar_ctl_m2c(*): got data!, len = %i", m->datalen); 
     
    455478 if ( m->data[0] != 0 ) { 
    456479  ROAR_DBG("roar_ctl_m2c(*): wrong version!"); 
    457   return -1; 
    458  } 
    459  
    460  if ( m->datalen < 3 ) 
    461   return -1; 
     480  roar_err_set(ROAR_ERROR_NSVERSION); 
     481  return -1; 
     482 } 
     483 
     484 if ( m->datalen < 3 ) { 
     485  roar_err_set(ROAR_ERROR_MSGSIZE); 
     486  return -1; 
     487 } 
    462488 
    463489 ROAR_DBG("roar_ctl_m2c(*): have usable data!"); 
     
    467493 for (i = 0; i < ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT; i++) 
    468494  c->streams[i] = -1; 
     495 
     496 if ( m->data[2] < 0 || m->data[2] > ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT ) { 
     497  roar_err_set(ROAR_ERROR_TOOMANYARGS); 
     498  return -1; 
     499 } 
    469500 
    470501 for (i = 0; i < m->data[2]; i++) 
     
    555586 } 
    556587 
     588 roar_err_set(ROAR_ERROR_NOENT); 
    557589 return -1; 
    558590} 
     
    592624 } 
    593625 
     626 roar_err_set(ROAR_ERROR_NOENT); 
    594627 return -1; 
    595628} 
     
    632665   return _libroar_ot[i].ot; 
    633666 
     667 roar_err_set(ROAR_ERROR_NOENT); 
    634668 return -1; 
    635669} 
     
    642676   return _libroar_ot[i].name; 
    643677 
     678 roar_err_set(ROAR_ERROR_NOENT); 
    644679 return NULL; 
    645680} 
     
    650685 uint_least32_t s; 
    651686 
    652  if ( dst == NULL || src == NULL || dstchans < 0 || srcchans < 0 ) 
    653   return -1; 
     687 if ( dst == NULL || src == NULL ) { 
     688  roar_err_set(ROAR_ERROR_FAULT); 
     689  return -1; 
     690 } 
     691 
     692 if ( dstchans < 0 || srcchans < 0 ) { 
     693  roar_err_set(ROAR_ERROR_INVAL); 
     694  return -1; 
     695 } 
    654696 
    655697 if ( dstchans == srcchans ) { 
     
    709751       break; 
    710752      default: 
     753        roar_err_set(ROAR_ERROR_NOTSUP); 
    711754        return -1; 
    712755       break; 
     
    741784       break; 
    742785      default: 
     786        roar_err_set(ROAR_ERROR_NOTSUP); 
    743787        return -1; 
    744788       break; 
     
    772816       break; 
    773817      default: 
     818        roar_err_set(ROAR_ERROR_NOTSUP); 
    774819        return -1; 
    775820       break; 
     
    802847       break; 
    803848      default: 
     849        roar_err_set(ROAR_ERROR_NOTSUP); 
    804850        return -1; 
    805851       break; 
     
    831877       break; 
    832878      default: 
     879        roar_err_set(ROAR_ERROR_NOTSUP); 
    833880        return -1; 
    834881       break; 
     
    836883    break; 
    837884   default: 
     885     roar_err_set(ROAR_ERROR_NOTSUP); 
    838886     return -1; 
    839887    break; 
  • libroar/enumdev.c

    r5138 r5145  
    337337 int i; 
    338338 
    339  if ( servs == NULL ) 
    340   return -1; 
     339 if ( servs == NULL ) { 
     340  roar_err_set(ROAR_ERROR_FAULT); 
     341  return -1; 
     342 } 
    341343 
    342344 for (i = 0; (c = &(servs[i]))->server != NULL; i++) { 
     
    361363 size_t ret; 
    362364 
    363  if ( servs == NULL ) 
    364   return -1; 
     365 if ( servs == NULL ) { 
     366  roar_err_set(ROAR_ERROR_FAULT); 
     367  return -1; 
     368 } 
    365369 
    366370 for (ret = 0; servs[ret].server != NULL; ret++); 
  • libroar/keyval.c

    r4708 r5145  
    4040 ssize_t i; 
    4141 
     42 if ( kv == NULL || key == NULL ) { 
     43  roar_err_set(ROAR_ERROR_FAULT); 
     44  return NULL; 
     45 } 
     46 
    4247 if ( casesens ) 
    4348  sc = strcmp; 
     
    4853 } 
    4954 
     55 roar_err_set(ROAR_ERROR_NOENT); 
    5056 return NULL; 
    5157} 
     
    6773 int last_was_seg = 0; 
    6874 
    69  if ( kv == NULL || str == NULL ) 
     75 if ( kv == NULL || str == NULL ) { 
     76  roar_err_set(ROAR_ERROR_FAULT); 
    7077  return -1; 
     78 } 
    7179 
    7280 // we currently do not support quotes 
    73  if ( quotes ) 
     81 if ( quotes ) { 
     82  roar_err_set(ROAR_ERROR_NOTSUP); 
    7483  return -1; 
     84 } 
    7585 
    7686 if ( fdel == NULL ) 
  • libroar/ltm.c

    r4873 r5145  
    6565 size_t i; 
    6666 
    67  if ( mt == 0 || streams == NULL || slen == 0 || mes == NULL || buf == NULL ) { 
     67 if ( mt == 0 ) { 
    6868  roar_err_set(ROAR_ERROR_INVAL); 
     69  return -1; 
     70 } 
     71 
     72 if ( streams == NULL || slen == 0 || mes == NULL || buf == NULL ) { 
     73  roar_err_set(ROAR_ERROR_FAULT); 
    6974  return -1; 
    7075 } 
     
    172177 int    i; 
    173178 
    174  if ( con == NULL ) 
    175   return NULL; 
    176  
    177  if ( streams == NULL || slen == 0 ) 
    178   return NULL; 
     179 if ( con == NULL ) { 
     180  roar_err_set(ROAR_ERROR_FAULT); 
     181  return NULL; 
     182 } 
     183 
     184 if ( streams == NULL || slen == 0 ) { 
     185  roar_err_set(ROAR_ERROR_FAULT); 
     186  return NULL; 
     187 } 
    179188 
    180189 if ( roar_ltm_pack_req(mt, window, streams, slen, &mes, &buf, ROAR_LTM_SST_GET_RAW) == -1 ) 
     
    238247} 
    239248 
    240 #define _CKNULL(x) if ( (x) == NULL ) return -1 
    241 #define _RETMEMBERCKED(x,m) _CKNULL(x); return (x)->m 
     249#define _CKNULL(x) if ( (x) == NULL ) { roar_err_set(ROAR_ERROR_FAULT); return -1; } 
     250#define _RETMEMBERCKED(x,m) _CKNULL(x) return (x)->m 
    242251 
    243252int roar_ltm_get_numstreams(struct roar_ltm_result * res) { 
     
    258267 ROAR_DBG("roar_ltm_get_streamptr(res=%p, streamidx=%i) = ?", res, streamidx); 
    259268 
    260  if ( res == NULL || streamidx < 0 || streamidx >= res->streams ) 
    261   return NULL; 
     269 if ( res == NULL || streamidx < 0 || streamidx >= res->streams ) { 
     270  roar_err_set(ROAR_ERROR_FAULT); 
     271  return NULL; 
     272 } 
    262273 
    263274 ptr = res->data; 
     
    294305 ROAR_DBG("roar_ltm_extract(res=%p, mt=0x%.4x, streamidx=%i, channel=%i) = ?", res, mt, streamidx, channel); 
    295306 
    296  if ( roar_ltm_numbits(mt) != 1 ) 
    297   return -1; 
     307 if ( roar_ltm_numbits(mt) != 1 ) { 
     308  roar_err_set(ROAR_ERROR_INVAL); 
     309  return -1; 
     310 } 
    298311 
    299312 ROAR_DBG("roar_ltm_extract(res=%p, mt=0x%.4x, streamidx=%i, channel=%i) = ?", res, mt, streamidx, channel); 
     
    306319 ROAR_DBG("roar_ltm_extract(res=%p, mt=0x%.4x, streamidx=%i, channel=%i): numchans=%i", res, mt, streamidx, channel, numchans); 
    307320 
    308  if ( channel >= numchans ) 
    309   return -1; 
     321 if ( channel >= numchans ) { 
     322  roar_err_set(ROAR_ERROR_RANGE); 
     323  return -1; 
     324 } 
    310325 
    311326 ptr++; 
  • libroar/stream.c

    r5072 r5145  
    8585                     unsigned int channels, unsigned int bits, unsigned int codec) { 
    8686 
    87  if ( s == NULL ) 
    88   return -1; 
     87 if ( s == NULL ) { 
     88  roar_err_set(ROAR_ERROR_FAULT); 
     89  return -1; 
     90 } 
    8991 
    9092 s->fh         = -1; 
     
    115117 
    116118int roar_stream_set_rel_id(struct roar_stream * s, int id) { 
    117  if ( s == NULL ) 
    118   return -1; 
     119 if ( s == NULL ) { 
     120  roar_err_set(ROAR_ERROR_FAULT); 
     121  return -1; 
     122 } 
    119123 
    120124 s->pos_rel_id = id; 
     
    124128 
    125129int roar_stream_get_rel_id(struct roar_stream * s) { 
    126  if ( s == NULL ) 
    127   return -1; 
     130 if ( s == NULL ) { 
     131  roar_err_set(ROAR_ERROR_FAULT); 
     132  return -1; 
     133 } 
    128134 
    129135 return s->pos_rel_id; 
     
    131137 
    132138int roar_stream_new_by_id(struct roar_stream * s, int id) { 
    133  if ( s == NULL ) 
    134   return -1; 
     139 if ( s == NULL ) { 
     140  roar_err_set(ROAR_ERROR_FAULT); 
     141  return -1; 
     142 } 
    135143 
    136144 if ( roar_stream_new_empty(s) == -1 ) 
     
    141149 
    142150int roar_stream_new_empty(struct roar_stream * s) { 
    143  if ( s == NULL ) 
    144   return -1; 
     151 if ( s == NULL ) { 
     152  roar_err_set(ROAR_ERROR_FAULT); 
     153  return -1; 
     154 } 
    145155 
    146156 return roar_stream_new(s, 0, 0, 0, 0); 
     
    148158 
    149159int roar_stream_set_id (struct roar_stream * s, int id) { 
    150  if ( s == NULL ) 
    151   return -1; 
     160 if ( s == NULL ) { 
     161  roar_err_set(ROAR_ERROR_FAULT); 
     162  return -1; 
     163 } 
    152164 
    153165 s->id = id; 
     
    157169 
    158170int roar_stream_get_id (struct roar_stream * s) { 
    159  if ( s == NULL ) 
    160   return -1; 
     171 if ( s == NULL ) { 
     172  roar_err_set(ROAR_ERROR_FAULT); 
     173  return -1; 
     174 } 
    161175 
    162176 return s->id; 
     
    164178 
    165179int roar_stream_set_fh (struct roar_stream * s, int fh) { 
    166  if ( s == NULL ) 
    167   return -1; 
     180 if ( s == NULL ) { 
     181  roar_err_set(ROAR_ERROR_FAULT); 
     182  return -1; 
     183 } 
    168184 
    169185 s->fh = fh; 
     
    173189 
    174190int roar_stream_get_fh (struct roar_stream * s) { 
    175  if ( s == NULL ) 
    176   return -1; 
     191 if ( s == NULL ) { 
     192  roar_err_set(ROAR_ERROR_FAULT); 
     193  return -1; 
     194 } 
    177195 
    178196 return s->fh; 
     
    180198 
    181199int roar_stream_set_dir (struct roar_stream * s, int dir) { 
    182  if ( s == NULL ) 
    183   return -1; 
     200 if ( s == NULL ) { 
     201  roar_err_set(ROAR_ERROR_FAULT); 
     202  return -1; 
     203 } 
    184204 
    185205 s->dir = dir; 
     
    189209 
    190210int roar_stream_get_dir (struct roar_stream * s) { 
    191  if ( s == NULL ) 
    192   return -1; 
     211 if ( s == NULL ) { 
     212  roar_err_set(ROAR_ERROR_FAULT); 
     213  return -1; 
     214 } 
    193215 
    194216 return s->dir; 
     
    232254 int len = 0; 
    233255 
    234  if ( host == NULL ) 
    235   return -1; 
     256 if ( host == NULL ) { 
     257  roar_err_set(ROAR_ERROR_FAULT); 
     258  return -1; 
     259 } 
    236260 
    237261 ROAR_DBG("roar_stream_connect_to_ask(*): Ask the server to connect to: %s:%i", host, port); 
     
    249273 len = strlen(host); 
    250274 
    251  if ( len > 76 ) 
    252   return -1; 
     275 if ( len > 76 ) { 
     276  roar_err_set(ROAR_ERROR_NAMETOOLONG); 
     277  return -1; 
     278 } 
    253279 
    254280 strncpy(&(m.data[4]), host, len); 
     
    265291 struct roar_message m; 
    266292 int confh; 
     293 
     294 if ( con == NULL || s == NULL ) { 
     295  roar_err_set(ROAR_ERROR_FAULT); 
     296  return -1; 
     297 } 
     298 
     299 if ( fh < 0 ) { 
     300  roar_err_set(ROAR_ERROR_INVAL); 
     301  return -1; 
     302 } 
    267303 
    268304 memset(&m,  0, sizeof(m)); 
     
    310346 int i; 
    311347 
     348 if ( con == NULL || s == NULL ) { 
     349  roar_err_set(ROAR_ERROR_FAULT); 
     350  return -1; 
     351 } 
     352 
     353 if ( client < 0 ) { 
     354  roar_err_set(ROAR_ERROR_INVAL); 
     355  return -1; 
     356 } 
     357 
    312358 memset(&m,  0, sizeof(m)); 
    313359 
     
    337383 struct roar_message m; 
    338384 
     385 if ( con == NULL || s == NULL || data == NULL ) { 
     386  roar_err_set(ROAR_ERROR_FAULT); 
     387  return -1; 
     388 } 
     389 
    339390 memset(&m,  0, sizeof(m)); 
    340391 
     
    361412 roar_debug_warn_obsolete("roar_stream_send_data", "roar_vio_write", NULL); 
    362413 
    363  if ( s == NULL ) 
    364   return -1; 
     414 if ( s == NULL ) { 
     415  roar_err_set(ROAR_ERROR_FAULT); 
     416  return -1; 
     417 } 
    365418 
    366419 if ( s->fh == -1 ) { 
    367   if ( con == NULL ) 
     420  if ( con == NULL ) { 
     421   roar_err_set(ROAR_ERROR_NOTSUP); 
    368422   return -1; 
     423  } 
    369424 
    370425  if ( roar_stream_add_data(con, s, data, len) == -1 ) 
     
    375430 
    376431#ifdef ROAR_HAVE_IO_POSIX 
    377  return write(s->fh, data, len); 
     432 return ROAR_NETWORK_WRITE(s->fh, data, len); 
    378433#endif 
    379434 
     435 roar_err_set(ROAR_ERROR_NOTSUP); 
    380436 return -1; 
    381437} 
     
    385441 uint16_t * data = (uint16_t *) m.data; 
    386442 int i; 
     443 
     444 if ( con == NULL || s == NULL || info == NULL ) { 
     445  roar_err_set(ROAR_ERROR_FAULT); 
     446  return -1; 
     447 } 
    387448 
    388449 memset(&m,  0, sizeof(m)); 
     
    410471 } 
    411472 
    412  if ( m.datalen < 7*2 ) 
    413   return -1; 
    414  
    415  if ( data[0] != 0 || data[1] != 1 ) 
    416   return -1; 
     473 if ( m.datalen < 7*2 ) { 
     474  roar_err_set(ROAR_ERROR_MSGSIZE); 
     475  return -1; 
     476 } 
     477 
     478 if ( data[0] != 0 || data[1] != 1 ) { 
     479  roar_err_set(ROAR_ERROR_NSVERSION); 
     480  return -1; 
     481 } 
    417482 
    418483 memset(info, 0, sizeof(struct roar_stream_info)); 
     
    459524 uint16_t * data = (uint16_t *) m.data; 
    460525 
    461  if ( con == NULL || s == NULL || name == NULL || len == 0 ) 
    462   return -1; 
     526 if ( con == NULL || s == NULL || name == NULL || len == 0 ) { 
     527  roar_err_set(ROAR_ERROR_FAULT); 
     528  return -1; 
     529 } 
    463530 
    464531 name[0] = 0; // just in case... 
     
    489556 ROAR_DBG("roar_stream_get_name(*) = ?"); 
    490557 
    491  if ( m.datalen < 4 ) 
    492   return -1; 
     558 if ( m.datalen < 4 ) { 
     559  roar_err_set(ROAR_ERROR_MSGSIZE); 
     560  return -1; 
     561 } 
    493562 
    494563 data[0] = ROAR_NET2HOST16(data[0]); 
     
    497566 ROAR_DBG("roar_stream_get_name(*) = ?"); 
    498567 
    499  if ( data[0] != 0 || data[1] != ROAR_STREAM_PARA_NAME ) 
    500   return -1; 
     568 if ( data[0] != 0 ) { 
     569  roar_err_set(ROAR_ERROR_NSVERSION); 
     570  return -1; 
     571 } 
     572 
     573 if ( data[1] != ROAR_STREAM_PARA_NAME ) { 
     574  roar_err_set(ROAR_ERROR_TYPEMM); 
     575  return -1; 
     576 } 
    501577 
    502578 m.datalen -= 4; 
     
    521597 ROAR_DBG("roar_stream_get_chanmap(con=%p, s=%p, map=%p, len=%p) = ?", con, s, map, len); 
    522598 
    523  if ( con == NULL || s == NULL || map == NULL || len == NULL ) 
    524   return -1; 
    525  
    526  if ( *len == 0 ) 
    527   return -1; 
     599 if ( con == NULL || s == NULL || map == NULL || len == NULL ) { 
     600  roar_err_set(ROAR_ERROR_FAULT); 
     601  return -1; 
     602 } 
     603 
     604 if ( *len == 0 ) { 
     605  roar_err_set(ROAR_ERROR_INVAL); 
     606  return -1; 
     607 } 
    528608 
    529609 memset(&m, 0, sizeof(m)); 
     
    549629 ROAR_DBG("roar_stream_get_chanmap(con=%p, s=%p{.id=%i}, map=%p, len=%p) = ?", con, s, s->id, map, len); 
    550630 
    551  if ( m.datalen < 4 ) 
    552   return -1; 
     631 if ( m.datalen < 4 ) { 
     632  roar_err_set(ROAR_ERROR_MSGSIZE); 
     633  return -1; 
     634 } 
    553635 
    554636 data[0] = ROAR_NET2HOST16(data[0]); 
     
    557639 ROAR_DBG("roar_stream_get_chanmap(con=%p, s=%p{.id=%i}, map=%p, len=%p) = ?", con, s, s->id, map, len); 
    558640 
    559  if ( data[0] != 0 || data[1] != ROAR_STREAM_PARA_CHANMAP ) 
    560   return -1; 
     641 if ( data[0] != 0 ) { 
     642  roar_err_set(ROAR_ERROR_NSVERSION); 
     643  return -1; 
     644 } 
     645 
     646 if ( data[1] != ROAR_STREAM_PARA_CHANMAP ) { 
     647  roar_err_set(ROAR_ERROR_TYPEMM); 
     648  return -1; 
     649 } 
    561650 
    562651 ROAR_DBG("roar_stream_get_chanmap(con=%p, s=%p{.id=%i}, map=%p, len=%p) = ?", con, s, s->id, map, len); 
     
    564653 m.datalen -= 4; 
    565654 
    566  if ( m.datalen > *len ) 
    567   return -1; 
     655 if ( m.datalen > *len ) { 
     656  roar_err_set(ROAR_ERROR_NOMEM); 
     657  return -1; 
     658 } 
    568659 
    569660 ROAR_DBG("roar_stream_get_chanmap(con=%p, s=%p{.id=%i}, map=%p, len=%p) = ?", con, s, s->id, map, len); 
     
    581672 uint16_t * data = (uint16_t *) m.data; 
    582673 
    583  if ( con == NULL || s == NULL || map == NULL ) 
    584   return -1; 
    585  
    586  if ( len == 0 ) 
     674 if ( con == NULL || s == NULL || map == NULL ) { 
     675  roar_err_set(ROAR_ERROR_FAULT); 
     676  return -1; 
     677 } 
     678 
     679 if ( len == 0 ) { 
     680  roar_err_set(ROAR_ERROR_INVAL); 
    587681  return 0; 
     682 } 
    588683 
    589684 memset(&m, 0, sizeof(m)); 
     
    622717 uint16_t * data = (uint16_t *) m.data; 
    623718 int i; 
     719 
     720 if ( con == NULL || s == NULL ) { 
     721  roar_err_set(ROAR_ERROR_FAULT); 
     722  return -1; 
     723 } 
    624724 
    625725 memset(&m,  0, sizeof(m)); 
     
    662762 int i; 
    663763 
     764 if ( con == NULL || s == NULL ) { 
     765  roar_err_set(ROAR_ERROR_FAULT); 
     766  return -1; 
     767 } 
     768 
    664769 memset(&m,  0, sizeof(m)); 
    665770 
     
    692797 int i; 
    693798 
    694  if ( !(s && m) ) 
    695   return -1; 
     799 if ( s == NULL || m == NULL ) { 
     800  roar_err_set(ROAR_ERROR_FAULT); 
     801  return -1; 
     802 } 
    696803 
    697804 m->datalen = _ROAR_STREAM_MESSAGE_LEN; 
     
    719826 int i; 
    720827 
    721  if ( !(s && m) ) 
    722   return -1; 
    723  
    724  if ( m->datalen != _ROAR_STREAM_MESSAGE_LEN ) 
    725   return -1; 
     828 if ( s == NULL || m == NULL ) { 
     829  roar_err_set(ROAR_ERROR_FAULT); 
     830  return -1; 
     831 } 
     832 
     833 if ( m->datalen != _ROAR_STREAM_MESSAGE_LEN ) { 
     834  roar_err_set(ROAR_ERROR_MSGSIZE); 
     835  return -1; 
     836 } 
    726837 
    727838 s->pos = m->pos; 
     
    9251036  return guess; 
    9261037 
    927  if ( codec == NULL || *codec == 0 ) 
    928   return ROAR_CODEC_DEFAULT; 
    929  
    9301038 for (i = 0; _libroar_codec[i].codec != -1; i++) 
    9311039  if ( strcasecmp(_libroar_codec[i].name, codec) == 0 ) 
    9321040   return _libroar_codec[i].codec; 
    9331041 
     1042 roar_err_set(ROAR_ERROR_NOENT); 
    9341043 return -1; 
    9351044} 
     
    9491058 int i; 
    9501059 
    951  if ( mime == NULL || *mime == 0 ) 
    952   return -1; 
     1060 if ( mime == NULL ) { 
     1061  roar_err_set(ROAR_ERROR_FAULT); 
     1062  return -1; 
     1063 } 
     1064 
     1065 if ( *mime == 0 ) { 
     1066  roar_err_set(ROAR_ERROR_INVAL); 
     1067  return -1; 
     1068 } 
    9531069 
    9541070 for (i = 0; _libroar_codec[i].codec != -1; i++) 
     
    9571073    return _libroar_codec[i].codec; 
    9581074 
     1075 roar_err_set(ROAR_ERROR_NOENT); 
    9591076 return -1; 
    9601077} 
     
    9671084   return _libroar_codec[i].mime; 
    9681085 
     1086 roar_err_set(ROAR_ERROR_NOENT); 
    9691087 return NULL; 
    9701088} 
     
    9811099 
    9821100 if ( ret == 0 && rate[0] != '0' ) { 
     1101  roar_err_set(ROAR_ERROR_NOENT); 
    9831102  return -1; 
    9841103 } 
     
    9981117 
    9991118 if ( ret == 0 && bits[0] != '0' ) { 
     1119  roar_err_set(ROAR_ERROR_NOENT); 
    10001120  return -1; 
    10011121 } 
     
    10211141 
    10221142 if ( ret == 0 && channels[0] != '0' ) { 
     1143  roar_err_set(ROAR_ERROR_NOENT); 
    10231144  return -1; 
    10241145 } 
     
    10651186 int i; 
    10661187 
     1188 roar_err_clear(); 
     1189 
    10671190 for (i = 0; _libroar_role[i].name != NULL; i++) 
    10681191  if ( !strcasecmp(_libroar_role[i].name, role) ) 
    10691192   return _libroar_role[i].role; 
    10701193 
     1194 roar_err_set(ROAR_ERROR_NOENT); 
    10711195 return ROAR_ROLE_UNKNOWN; 
    10721196} 
Note: See TracChangeset for help on using the changeset viewer.