sipp.cpp

sipp is sip protocal testing tool.

        (*ptr2 != ' ') && 
        (*ptr2 != '\t') && 
        (*ptr2 != '\r') && 
        (*ptr2 != '\n')) { 
    ptr2 ++;
  } 

  if(!*ptr2) { ERROR("(3) No valid Call-ID: header in reply"); }

  backup = *ptr2;
  *ptr2 = 0;
  if ((ptr3 = strstr(ptr1, "///")) != 0) ptr1 = ptr3+3;
  strcpy(call_id, ptr1);
  *ptr2 = backup;
  return (char *) call_id;
}

unsigned long int get_cseq_value(char *msg) {
  char *ptr1;
 

  // no short form for CSeq:
  ptr1 = strstr(msg, "\r\nCSeq:");
  if(!ptr1) { ptr1 = strstr(msg, "\r\nCSEQ:"); }
  if(!ptr1) { ptr1 = strstr(msg, "\r\ncseq:"); }
  if(!ptr1) { ptr1 = strstr(msg, "\r\nCseq:"); }
  if(!ptr1) { WARNING_P1("No valid Cseq header in request %s", msg); return 0;}
 
  ptr1 += 7;
 
  while((*ptr1 == ' ') || (*ptr1 == '\t')) {++ptr1;}
 
  if(!(*ptr1)) { WARNING("No valid Cseq data in header"); return 0;}
 
  return strtoul(ptr1, NULL, 10);
}

unsigned long get_reply_code(char *msg)
{
  while((msg) && (*msg != ' ') && (*msg != '\t')) msg ++;
  while((msg) && ((*msg == ' ') || (*msg == '\t'))) msg ++;

  if ((msg) && (strlen(msg)>0)) {
    return atol(msg);
  } else {
    return 0;
  }
}

/*************************** I/O functions ***************************/

#ifdef _USE_OPENSSL
int recv_all_tls(SSL *ssl, char *buffer, int size, int trace_id)
{
  int    recv_size = 0;
  char * start_buffer = buffer;
  int    to_be_recvd = size;
  int    part_size ;
  int    err;

  recv_size = SSL_read(ssl,buffer, size);
  sip_tls_error_handling(ssl, recv_size);
  if(recv_size <= 0) {
	   
    if(recv_size != 0) {
      nb_net_recv_errors++;
      WARNING_P3("TLS %d Recv error : size = %d,Dummy : %d ",
                 trace_id, recv_size, trace_id);
    } else {
      /* This is normal for a server to have its client close
       * the connection */
      if(toolMode != MODE_SERVER) {
        WARNING_P3("TLS %d Recv error : size = %d, dummy : %d  "
                   "remote host closed connection",
                   trace_id, recv_size,trace_id);
        nb_net_recv_errors++;
      }
    }
  }
  
  return recv_size;
}
#endif

/* Allocate a poll buffer. */
struct pollbuf *alloc_pollbuf(char *buffer, int size) {
  struct pollbuf *pollbuf;

  pollbuf = (struct pollbuf *)malloc(sizeof(struct pollbuf));
  if (!pollbuf) {
	ERROR("Could not allocate poll buffer!\n");
  }
  pollbuf->buf = buffer;
  pollbuf->len = size;
  pollbuf->offset = 0;
  pollbuf->next = NULL;

  return pollbuf;
}

/* Free a poll buffer. */
void free_pollbuf(struct pollbuf *pollbuf) {
  free(pollbuf->buf);
  free(pollbuf);
}

/* This is used to pull out data from the pollbuffer. */
int recv_from_pollbuffer(int idx, char *buffer, int size) {
  int avail;
  int read = 0;

  while (pollbuffers[idx] && (size > 0)) {
    avail = pollbuffers[idx]->len - pollbuffers[idx]->offset;
    if (avail > size) {
      avail = size;
    }

    memcpy(buffer, pollbuffers[idx]->buf + pollbuffers[idx]->offset, avail);

    /* Update our buffer and return value. */
    read += avail;
    size -= avail;
    buffer += avail;
    pollbuffers[idx]->offset += avail;

    /* Have we emptied the buffer? */
    if (pollbuffers[idx]->offset == pollbuffers[idx]->len) {
      struct pollbuf *next = pollbuffers[idx]->next;
      free_pollbuf(pollbuffers[idx]);
      pollbuffers[idx] = next;
      if (!next) {
	outstanding_poll_msgs--;
      }
    }
  }

  return read;
}

/* Put extra data back in the poll buffer so the next read will pick it up. */
void pushback_pollbuffer(int idx, char *buffer, int size) {
  struct pollbuf *pollbuf = alloc_pollbuf(buffer, size);
  if (!pollbuffers[idx]) {
    outstanding_poll_msgs++;
  }
  pollbuf->next = pollbuffers[idx];
  pollbuffers[idx] = pollbuf;
}

/* Refill the poll buffer. */
int refill_pollbuffer(int sock, int idx, int size, int trace_id) {
  int readsize = tcp_readsize;
  struct pollbuf *pollbuf;
  char *buffer;
  int ret;

  assert (pollbuffers[idx] == NULL);

  if (readsize < size) {
    readsize = size;
  }

  buffer = (char *)malloc(readsize);
  if (!buffer) {
    ERROR("Could not allocate memory for read!");
  }
  pollbuf = alloc_pollbuf(buffer, readsize);

  ret = recv(sock, buffer, readsize, 0);
  if (ret <= 0) {
	free_pollbuf(pollbuf);
	return ret;
  }

  pollbuf->len = ret;
  pollbuffers[idx] = pollbuf;

  outstanding_poll_msgs++;

  return ret;
}

void tcp_recv_error(int error, int trace_id, int sock) {
  /* We are assuming end of connection, but in fact we could just be closed.
   * What should we really do? */
  if (error != 0) {
      nb_net_recv_errors++;
      WARNING_P2("TCP %d Recv error : sock = %d", trace_id, sock);
      WARNING_NO("TCP Recv error");
      return;
  }

#ifdef __3PCC__
  if (toolMode == MODE_3PCC_CONTROLLER_B) {
    /* In 3PCC controller B mode, twin socket is closed at peer closing.
     * This is a normal case: 3PCC controller B should end now */
    if (localTwinSippSocket) close(localTwinSippSocket);
    if (twinSippSocket) close(twinSippSocket);
    ERROR("3PCC controller A has ended -> exiting");
  } else
#endif
  /* This is normal for a server to have its client close the connection */
  if (toolMode == MODE_SERVER) {
	WARNING("Client must have closed the connection!\n");
	return;
  }

  WARNING_P2("TCP %d Recv error : sock = %d, "
      "remote host closed connection",
      trace_id, sock);

#ifdef __3PCC__
  if(sock == twinSippSocket || sock == localTwinSippSocket) {
    int L_poll_idx = 0 ;
    quitting = 1;
    for((L_poll_idx) = 0;
	(L_poll_idx) < pollnfds;
	(L_poll_idx)++) {
      if(pollfiles[L_poll_idx].fd == twinSippSocket) {
	pollset_remove(L_poll_idx);
      }
      if(pollfiles[L_poll_idx].fd == localTwinSippSocket) {
	pollset_remove(L_poll_idx);
      }
    }
    if(twinSippSocket) {
      shutdown(twinSippSocket, SHUT_RDWR);
      close(twinSippSocket);
      twinSippSocket = 0 ;
    }
    if(localTwinSippSocket) {
      shutdown(localTwinSippSocket, SHUT_RDWR);
      close(localTwinSippSocket);
      localTwinSippSocket = 0 ;
    }
  }
#endif
  nb_net_recv_errors++;
}

int recv_pollbuff_tcp(int sock, int idx, char *buffer, int size, int trace_id) {
  int    recv_size = 0;
  int    part_size ;
  int ret;

  do {
    part_size = recv_from_pollbuffer(idx, buffer, size);
    if (part_size <= 0) {
	if ((ret = refill_pollbuffer(sock, idx, size, trace_id)) <= 0) {
	  tcp_recv_error(ret, trace_id, sock);
	  return recv_size;
	} else {
	  part_size = recv_from_pollbuffer(idx, buffer, size);
	}
    }
    size -= part_size;
    buffer += part_size;
    recv_size += part_size;
  } while (size > 0 && part_size > 0);

  return recv_size;
}

#ifdef _USE_OPENSSL
int recv_tls_message(SSL * ssl,
                     char *buffer,
                     int buffer_size,
                     E_Alter_YesNo alter_msg)
{
  int len = 0;
  int recv_size;
  char * ctl_hdr;
  int content_length;

  len = recv_size = recv_all_tls(ssl, buffer, buffer_size, 1);

  if(recv_size <= 0) {
    return recv_size;
  }

  if(len >= buffer_size) {
    ERROR("TLS msg too big");
  }
  buffer[len] = 0;
  return len;
}
#endif
    
int recv_tcp_message(int sock,
		     int idx,
                     char *buffer,
                     int buffer_size,
                     E_Alter_YesNo alter_msg,
                     E_Alter_YesNo isControlMsg = E_ALTER_NO)
{
  int len = 0;
  int recv_size;
  char * ctl_hdr;
  int content_length;
  bool short_form;

  short_form = false;

  // Try to read SIP Header Message only
  // or CMD Message
  while(len < buffer_size) {
    // Read one char on tcp socket
    recv_size = recv_pollbuff_tcp(sock, idx, buffer +len, 1, 1);

    // Check read problem return
    if(recv_size <= 0) {
      return recv_size;
    }

    len++;

    // Search the end Message condition 
    if ((len > 3) && (isControlMsg == E_ALTER_NO)) {
      // In case of SIP Message \r\n follow by 
      // \r\n is header end
      if((buffer[len-1] == '\n') && 
         (buffer[len-2] == '\r') && 
         (buffer[len-3] == '\n') && 
         (buffer[len-4] == '\r')) {
        /* CRLF CRLF Detected */
        buffer[len] = 0;
        break;
      }
    }
    else
    {
      // In case of CMD Message
      // escape char is the end of message
      if((alter_msg==E_ALTER_NO) &&
         (buffer[len-1] == 27)) {
        /* End delimitor detected, stop receiving */
        buffer[len-1] = 0;
        return (len - 1);
      }
    }
  }

  if(len >= buffer_size) {
    ERROR("TCP msg too big");
  }
  
  // Now search the content length of the body
  // part of SIP or CMD Message
  ctl_hdr = strstr(buffer, "\r\nContent-Length:");
  if(!ctl_hdr) {ctl_hdr = strstr(buffer, "\r\nContent-length:"); }
  if(!ctl_hdr) {ctl_hdr = strstr(buffer, "\r\ncontent-Length:"); }
  if(!ctl_hdr) {ctl_hdr = strstr(buffer, "\r\ncontent-length:"); }
  if(!ctl_hdr) {ctl_hdr = strstr(buffer, "\r\nCONTENT-LENGTH:"); }
  if(!ctl_hdr) {ctl_hdr = strstr(buffer, "\r\nl:"); short_form = true; }

  // Content Length was found
  // Read its value
  if((ctl_hdr) && (alter_msg==E_ALTER_YES)) {
    if (short_form) {
      ctl_hdr += 4; 
    } else {
      ctl_hdr += 17; 
    }
    content_length = atoi(ctl_hdr);
  } else {
    content_length = 0;
  }
  
  // If a body exist read it
  if(content_length) {

    /* Ensure remaining content will fit in remaining buffer size */
    if(content_length > (buffer_size - len)) {
      ERROR("TCP msg too big");
    }
    // Read Body part 
    do {
      recv_size = recv_pollbuff_tcp(sock, idx, buffer + len, content_length, 2);
      
      if(recv_size <= 0) {
        return recv_size;
      }
      
      len += recv_size;
      content_length -= recv_size;
    } while(content_length);
  }
  
  // Add the final '\0'
  buffer[len] = 0;
  
  return len;
}

int decompress_if_needed(int sock, char *buff,  int len, void **st)
{
  if(compression && len) {
    if (useMessagef == 1) {	  
    struct timeval currentTime;
    GET_TIME (&currentTime);
    TRACE_MSG((s,
               "----------------------------------------------- %s\n"
               "Compressed message received, header :\n"
               "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x "
               "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
               CStat::instance()->formatTime(&currentTime),
               buff[0] , buff[1] , buff[2] , buff[3],
               buff[4] , buff[5] , buff[6] , buff[7],
               buff[8] , buff[9] , buff[10], buff[11],
               buff[12], buff[13]