Changeset 5608:584b36c566e2 in roaraudio for libroar


Ignore:
Timestamp:
07/31/12 15:31:35 (12 years ago)
Author:
phi
Branch:
default
Phase:
public
Message:

Handle super long client names well (Closes: #286)

Location:
libroar
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • libroar/basic.c

    r5471 r5608  
    510510  return -1; 
    511511 
    512  // specal hack to set an ilegal value used internaly in libroar: 
     512 // specal hack to set an illegal value used internaly in libroar: 
    513513 if ( fh == -2 ) 
    514514  fh = -1; 
     
    516516 if ( roar_vio_open_fh_socket(con->viocon, fh) != -1 ) { 
    517517  con->flags |= ROAR_CON_FLAGS_VIO; 
     518 } else { 
     519  return -1; 
    518520 } 
    519521 
     
    543545 
    544546struct roar_vio_calls * roar_get_connection_vio2 (struct roar_connection * con) { 
    545  if ( con == NULL ) 
     547 if ( con == NULL ) { 
     548  roar_err_set(ROAR_ERROR_FAULT); 
    546549  return NULL; 
     550 } 
    547551 
    548552 if ( con->flags & ROAR_CON_FLAGS_VIO ) 
     
    551555// TODO: try to open the VIO. 
    552556 
     557 roar_err_set(ROAR_ERROR_BADFH); 
    553558 return NULL; 
    554559} 
  • libroar/ctl.c

    r5462 r5608  
    161161int roar_get_client   (struct roar_connection * con, struct roar_client * client, int id) { 
    162162 struct roar_message m; 
     163 char * data = NULL; 
     164 int ret; 
    163165 
    164166 memset(&m, 0, sizeof(struct roar_message)); // make valgrind happy! 
     
    171173 ROAR_DBG("roar_get_client(*): id = %i", id); 
    172174 
    173  if ( roar_req(con, &m, NULL) == -1 ) 
     175 if ( roar_req(con, &m, &data) == -1 ) 
    174176  return -1; 
    175177 
     
    179181 ROAR_DBG("roar_get_client(*): got ok"); 
    180182 
    181  return roar_ctl_m2c(&m, client); 
     183 ret = roar_ctl_m2c2(&m, client, data); 
     184 
     185 if ( data != NULL ) 
     186  roar_mm_free(data); 
     187 
     188 return ret; 
    182189} 
    183190 
     
    376383} 
    377384 
    378 int roar_ctl_c2m      (struct roar_message * m, struct roar_client * c) { 
    379  int cur = 0; 
     385int roar_ctl_c2m2     (struct roar_message * m, struct roar_client * c, void ** data) { 
     386 char * d; 
     387 size_t cur = 0; 
    380388 int h; 
    381389 int i; 
    382390 int max_len; 
    383391 uint32_t pid; 
    384  signed long int len_rest; 
    385392 size_t nnode_len; 
     393 size_t needed_len = 3 + 5*4 + 18 /* 18 = current max size for blob */; 
    386394 
    387395 if ( c == NULL ) 
    388396  return -1; 
    389397 
    390  m->data[cur++] = 0;                       // 0: Version 
    391  m->data[cur++] = c->execed;               // 1: execed 
     398 if ( data != NULL ) 
     399  *data = NULL; 
     400 
     401 max_len = strlen(c->name); 
     402 needed_len += max_len; 
     403 
     404 for (i = 0; i < ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT; i++) 
     405  if ( c->streams[i] != -1 ) 
     406   needed_len++; 
     407 
     408 if ( needed_len > sizeof(m->data) ) { 
     409  if ( data == NULL ) { 
     410   needed_len -= max_len; 
     411   if ( needed_len > sizeof(m->data) ) { 
     412    roar_panic(ROAR_FATAL_ERROR_CPU_FAILURE, "needed_len > sizeof(m->data) happend."); 
     413    roar_err_set(ROAR_ERROR_BADCKSUM); 
     414    return -1; 
     415   } 
     416   max_len = sizeof(m->data) - needed_len; 
     417   needed_len = sizeof(m->data); 
     418   d = m->data; 
     419  } else { 
     420   d = roar_mm_malloc(needed_len); 
     421   if ( d == NULL ) 
     422    return -1; 
     423   *data = d; 
     424  } 
     425 } else { 
     426  d = m->data; 
     427 } 
     428 
     429 d[cur++] = 0;                       // 0: Version 
     430 d[cur++] = c->execed;               // 1: execed 
    392431 
    393432 h = 0; 
    394  for (i = 0; i < ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT; i++) { 
     433 for (i = 0; i < ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT; i++) 
    395434  if ( c->streams[i] != -1 ) 
    396    m->data[cur+1+h++] = c->streams[i]; 
    397  } 
    398  
    399  m->data[cur++] = h;                       // 2: num of streams 
     435   d[cur+1+h++] = c->streams[i]; 
     436 
     437 d[cur++] = h;                       // 2: num of streams 
    400438 cur += h; 
    401  
    402  max_len = strlen(c->name); 
    403439 
    404440 // TODO: add some code to check if this fits in the pkg 
     
    406442 //       and fully decieded about this function. 
    407443 
    408  m->data[cur++] = max_len; 
    409  
    410  strncpy((m->data)+cur, c->name, max_len); 
     444 d[cur++] = max_len; 
     445 
     446 strncpy(d+cur, c->name, max_len); 
    411447 
    412448 cur += max_len; 
    413449 
    414450 pid = ROAR_HOST2NET32(c->pid); 
    415  memcpy(&(m->data[cur]), &pid, 4); 
     451 memcpy(&(d[cur]), &pid, 4); 
    416452 cur += 4; 
    417453 
    418454 pid = ROAR_HOST2NET32(c->uid); 
    419  memcpy(&(m->data[cur]), &pid, 4); 
     455 memcpy(&(d[cur]), &pid, 4); 
    420456 cur += 4; 
    421457 
    422458 pid = ROAR_HOST2NET32(c->gid); 
    423  memcpy(&(m->data[cur]), &pid, 4); 
     459 memcpy(&(d[cur]), &pid, 4); 
    424460 cur += 4; 
    425461 
    426462 pid = ROAR_HOST2NET32(c->proto); 
    427  memcpy(&(m->data[cur]), &pid, 4); 
     463 memcpy(&(d[cur]), &pid, 4); 
    428464 cur += 4; 
    429465 
    430466 pid = ROAR_HOST2NET32(c->byteorder); 
    431  memcpy(&(m->data[cur]), &pid, 4); 
     467 memcpy(&(d[cur]), &pid, 4); 
    432468 cur += 4; 
    433469 
    434  len_rest = (long int)sizeof(m->data) - (long int)cur; 
    435  if ( len_rest < 0 ) { 
     470 if ( cur > needed_len ) { 
    436471  roar_panic(ROAR_FATAL_ERROR_MEMORY_CORRUPTION, NULL); 
    437472 } 
    438473 
    439  nnode_len = len_rest; 
    440  if ( roar_nnode_to_blob(&(c->nnode), &(m->data[cur]), &nnode_len) == 0 ) { 
     474 nnode_len = needed_len - cur; 
     475 if ( roar_nnode_to_blob(&(c->nnode), &(d[cur]), &nnode_len) == 0 ) { 
    441476  cur += nnode_len; 
    442477 } 
    443478 
     479 if ( cur > needed_len ) { 
     480  roar_panic(ROAR_FATAL_ERROR_MEMORY_CORRUPTION, NULL); 
     481 } 
     482 
    444483 m->datalen = cur; 
    445484 
     
    447486} 
    448487 
    449 int roar_ctl_m2c      (struct roar_message * m, struct roar_client * c) { 
     488int roar_ctl_m2c2      (struct roar_message * m, struct roar_client * c, void * data) { 
     489 char * d = data; 
    450490 uint32_t pid; 
    451491 size_t len; 
     
    463503 } 
    464504 
     505 if ( d == NULL ) { 
     506  if ( m->datalen > sizeof(m->data) ) { 
     507   roar_err_set(ROAR_ERROR_FAULT); 
     508   return -1; 
     509  } 
     510  d = m->data; 
     511 } 
     512 
    465513 ROAR_DBG("roar_ctl_m2c(*): got data!, len = %i", m->datalen); 
    466514 
    467  if ( m->data[0] != 0 ) { 
     515 if ( d[0] != 0 ) { 
    468516  ROAR_DBG("roar_ctl_m2c(*): wrong version!"); 
    469517  roar_err_set(ROAR_ERROR_NSVERSION); 
     
    478526 ROAR_DBG("roar_ctl_m2c(*): have usable data!"); 
    479527 
    480  c->execed = m->data[1]; 
     528 c->execed = d[1]; 
    481529 
    482530 for (i = 0; i < ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT; i++) 
    483531  c->streams[i] = -1; 
    484532 
    485  if ( m->data[2] < 0 || m->data[2] > ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT ) { 
     533 if ( d[2] < 0 || d[2] > ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT ) { 
    486534  roar_err_set(ROAR_ERROR_TOOMANYARGS); 
    487535  return -1; 
    488536 } 
    489537 
    490  for (i = 0; i < m->data[2]; i++) 
    491   c->streams[i] = m->data[3+i]; 
    492  
    493  cur = 3 + m->data[2]; 
    494  
    495  strncpy(c->name, (m->data)+cur+1, m->data[cur]); 
    496  c->name[(int)m->data[cur]] = 0; 
    497  
    498  cur += m->data[cur] + 1; 
    499  
    500  memcpy(&pid, &(m->data[cur]), 4); 
     538 for (i = 0; i < d[2]; i++) 
     539  c->streams[i] = d[3+i]; 
     540 
     541 cur = 3 + d[2]; 
     542 
     543 // check length here! 
     544 strncpy(c->name, d+cur+1, d[cur] > (sizeof(c->name)-1) ? sizeof(c->name)-1 : d[cur]); 
     545 c->name[(size_t)d[cur] > (sizeof(c->name)-1) ? sizeof(c->name)-1 : (size_t)d[cur]] = 0; 
     546 
     547 cur += d[cur] + 1; 
     548 
     549 memcpy(&pid, &(d[cur]), 4); 
    501550 c->pid = ROAR_NET2HOST32(pid); 
    502551 cur += 4; 
    503552 
    504  memcpy(&pid, &(m->data[cur]), 4); 
     553 memcpy(&pid, &(d[cur]), 4); 
    505554 c->uid = ROAR_NET2HOST32(pid); 
    506555 cur += 4; 
    507556 
    508  memcpy(&pid, &(m->data[cur]), 4); 
     557 memcpy(&pid, &(d[cur]), 4); 
    509558 c->gid = ROAR_NET2HOST32(pid); 
    510559 cur += 4; 
    511560 
    512561 if ( m->datalen >= cur+4 ) { 
    513   memcpy(&pid, &(m->data[cur]), 4); 
     562  memcpy(&pid, &(d[cur]), 4); 
    514563  c->proto = ROAR_NET2HOST32(pid); 
    515564  cur += 4; 
     
    519568 
    520569 if ( m->datalen >= cur+4 ) { 
    521   memcpy(&pid, &(m->data[cur]), 4); 
     570  memcpy(&pid, &(d[cur]), 4); 
    522571  c->byteorder = ROAR_NET2HOST32(pid); 
    523572  cur += 4; 
     
    528577 if ( m->datalen > cur ) { 
    529578  len = m->datalen - cur; 
    530   if ( roar_nnode_from_blob(&(c->nnode), &(m->data[cur]), &len) == 0 ) { 
     579  if ( roar_nnode_from_blob(&(c->nnode), &(d[cur]), &len) == 0 ) { 
    531580   cur += len; 
    532581  } else { 
     
    540589 
    541590 return 0; 
     591} 
     592 
     593int roar_ctl_c2m      (struct roar_message * m, struct roar_client * c) { 
     594 return roar_ctl_c2m2(m, c, NULL); 
     595} 
     596int roar_ctl_m2c      (struct roar_message * m, struct roar_client * c) { 
     597 return roar_ctl_m2c2(m, c, NULL); 
    542598} 
    543599 
  • libroar/proto.c

    r5467 r5608  
    148148} 
    149149 
     150static inline int _libroar_msgresyncer(struct roar_vio_calls  * vio, size_t len) { 
     151 char buffer[2*LIBROAR_BUFFER_MSGDATA]; // this is always called with len > LIBROAR_BUFFER_MSGDATA. 
     152 ssize_t ret; 
     153 size_t errorc = 0; 
     154 
     155 while (len && errorc < 4) { 
     156  ret = roar_vio_read(vio, buffer, len > sizeof(buffer) ? sizeof(buffer) : len); 
     157  if ( ret == (size_t)-1 ) { 
     158   errorc++; 
     159  } else { 
     160   errorc = 0; 
     161   len -= ret; 
     162  } 
     163 } 
     164 
     165 if ( len ) 
     166  return -1; // last error is still set. 
     167 return 0; 
     168} 
     169 
    150170int roar_vrecv_message2(struct roar_vio_calls  * vio, struct roar_message * mes, char ** data, 
    151171                        struct roar_error_frame * errorframe) { 
     
    269289 } else { 
    270290  if ( data == NULL ) { 
    271    roar_err_set(ROAR_ERROR_MSGSIZE); 
     291   if ( _libroar_msgresyncer(vio, mes->datalen) == -1 ) { 
     292    roar_err_set(ROAR_ERROR_BADCKSUM); 
     293   } else { 
     294    roar_err_set(ROAR_ERROR_MSGSIZE); 
     295   } 
    272296   return -1; 
    273297  } 
    274298 
    275299  if ( (*data = roar_mm_malloc(mes->datalen)) == NULL ) { 
    276    roar_err_set(ROAR_ERROR_NOMEM); 
     300   if ( _libroar_msgresyncer(vio, mes->datalen) == -1 ) { 
     301    roar_err_set(ROAR_ERROR_BADCKSUM); 
     302   } else { 
     303    roar_err_set(ROAR_ERROR_NOMEM); 
     304   } 
    277305   return -1; 
    278306  } 
Note: See TracChangeset for help on using the changeset viewer.