call.cpp

sipp is sip protocal testing tool.

        } else {
          /* Send a CANCEL */
          strcpy(L_param, "CANCEL sip:[service]@[remote_ip]:[remote_port] SIP/2.0\n");
          sprintf(L_param, "%s%s", L_param, "Via: SIP/2.0/[transport] [local_ip]:[local_port]\n");
          sprintf(L_param, "%s%s", L_param, "From: sipp <sip:sipp@[local_ip]:[local_port]>;tag=[call_number]\n");
          sprintf(L_param, "%s%s", L_param, "To: sut <sip:[service]@[remote_ip]:[remote_port]>[peer_tag_param]\n");
          sprintf(L_param, "%s%s", L_param, "Call-ID: [call_id]\n");
	       sprintf(L_param, "%sCSeq: 1 CANCEL\n", L_param);
          sprintf(L_param, "%s%s", L_param, "Contact: <sip:[local_ip]:[local_port];transport=[transport]>\n");
          sprintf(L_param, "%s%s", L_param,  "Content-Length: 0\n");
          res = sendBuffer(createSendingMessage((char*)(L_param),-1));
        }
      } else {
        /* Call is not established and the reply is not a 4XX, 5XX */
        /* and we didn't received any message. This is the case when */
        /* we are aborting after having send an INVITE and not received */
        /* any answer. */
        /* Do nothing ! */
      }
    } else {
      /* Call is established */
      char * src_recv = last_recv_msg ;
      char   L_msg_buffer[SIPP_MAX_MSG_SIZE];
      L_msg_buffer[0] = '\0';
      char * L_param = L_msg_buffer;
      strcpy(L_param, "BYE sip:[service]@[remote_ip]:[remote_port] SIP/2.0\n");
      sprintf(L_param, "%s%s", L_param, "Via: SIP/2.0/[transport] [local_ip]:[local_port]\n");
      sprintf(L_param, "%s%s", L_param, "From: sipp <sip:sipp@[local_ip]:[local_port]>;tag=[call_number]\n");
      sprintf(L_param, "%s%s", L_param, "To: sut <sip:[service]@[remote_ip]:[remote_port]>[peer_tag_param]\n");
      sprintf(L_param, "%s%s", L_param, "Call-ID: [call_id]\n");
      char * cseq;
      cseq = compute_cseq(src_recv);
      if (cseq != NULL) {
        sprintf(L_param, "%s%s BYE\n", L_param, compute_cseq(src_recv));
      }
      sprintf(L_param, "%s%s", L_param, "Contact: <sip:[local_ip]:[local_port];transport=[transport]>\n");
      sprintf(L_param, "%s%s", L_param,  "Content-Length: 0\n");
      res = sendBuffer(createSendingMessage((char*)(L_param),-1));
    }
  }

  delete_call(id);
  return false;
}

bool call::rejectCall()
{
  CStat::instance()->computeStat(CStat::E_CALL_FAILED);
  CStat::instance()->computeStat(CStat::E_FAILED_CALL_REJECTED);
  delete_call(id);
  return false;
}


#ifdef __3PCC__
int call::sendCmdMessage(int index)
{
  char * dest;
  char delimitor[2];
  delimitor[0]=27;
  delimitor[1]=0;

  if(scenario[index] -> M_sendCmdData) {
    // WARNING_P1("---PREPARING_TWIN_CMD---%s---", scenario[index] -> M_sendCmdData); 
    dest = createSendingMessage(scenario[index] -> M_sendCmdData, -1);
    strcat(dest, delimitor);
    //WARNING_P1("---SEND_TWIN_CMD---%s---", dest); 

    int rc;

    rc = send(twinSippSocket, 
              dest, 
              strlen(dest), 
              0);
    if(rc <  0) {
      CStat::instance()->computeStat(CStat::E_CALL_FAILED);
      CStat::instance()->computeStat(CStat::E_FAILED_CMD_NOT_SENT);
      delete_call(id);
      return(-1);
    }

    return(0);
  }
  else
    return(-1);
}


int call::sendCmdBuffer(char* cmd)
{
  char * dest;
  char delimitor[2];
  int  rc;

  delimitor[0]=27;
  delimitor[1]=0;

  dest = cmd ;

  strcat(dest, delimitor);


  rc = send(twinSippSocket, 
            dest, 
            strlen(dest), 
            0);
  if(rc <  0) {
    CStat::instance()->computeStat(CStat::E_CALL_FAILED);
    CStat::instance()->computeStat(CStat::E_FAILED_CMD_NOT_SENT);
    delete_call(id);
    return(-1);
  }

  return(0);
}

#endif

void call::getHexStringParam(char * dest, char * src, int * len)
{ 
  *len=0;
  /* Allows any hex coded string like '0x5B07F6' */
  while (isxdigit(*src)) {
    int val = get_decimal_from_hex(*src);
    src++;
    if (isxdigit(*src)) {
      val = (val << 4) + get_decimal_from_hex(*src);
      src++;
    }
    *dest++ = val & 0xff;
    (*len)++;
  }
}

char* call::getKeywordParam(char * src, char * param, char * output)
{
  char *key, *tmp;
  int len;

  len = 0;
  key = NULL;
  if(tmp = strstr(src, param)) {
    tmp += strlen(param);
    key = tmp;
    if ((*key == '0') && (*(key+1) == 'x')) {
      key += 2;
      getHexStringParam(output, key, &len);
      key += len * 2;
    } else {
      while (*key) {
        if (((key - src) > KEYWORD_SIZE) || (!(key - src))) {
          ERROR_P1("Syntax error parsing '%s' parameter", param);
        } else if (*key == ']' || *key < 33 || *key > 126) {
          strncpy(output, tmp, key-tmp);
          output[key-tmp] = '\0';
          break;
        }
        key++;
      }
    }
  } else {
    output[0] = '\0';
  }
  return key;
}

char* call::createSendingMessage(char * src, int P_index)
{
  static char msg_buffer[SIPP_MAX_MSG_SIZE+2];
 
  if(src != NULL) {
    char * dest = msg_buffer;
    char * key;
    char * length_marker = NULL;
    const char * auth_marker = NULL;
    int auth_marker_len = 0;
    int    offset = 0;
    int    len_offset = 0;
    char   current_line[MAX_HEADER_LEN];
    char * line_mark = NULL;

    current_line[0] = '\0';
    while(*src) {
      if (current_line[0] == '\0') {
        line_mark = NULL;
        line_mark = strchr(src, '\n');
        if (line_mark) {
          memcpy(current_line, src, line_mark - src);
          current_line[line_mark-src] = '\0';
        }
      }
      /* This hex encoding could be done in XML parsing, allowing us to skip
       * these conditionals and branches. */
      if ((*src == '\\') && (*(src+1) == 'x')) {
        /* Allows any hex coded char like '\x5B' ([) */
        src += 2;
        if (isxdigit(*src)) {
          int val = get_decimal_from_hex(*src);
          src++;
          if (isxdigit(*src)) {
            val = (val << 4) + get_decimal_from_hex(*src);
          }
          *dest++ = val & 0xff;
        }
        src++;
      } else if(*src == '[') {
        char keyword [KEYWORD_SIZE+1];
        src++;
        key = strchr(src, ']');
        if((!key) || ((key - src) > KEYWORD_SIZE) || (!(key - src))){
          ERROR_P1("Syntax error or invalid [keyword] in scenario while parsing '%s'", current_line);
        }
        memcpy(keyword, src,  key - src);
 
        keyword[key - src] = 0;
        src = key + 1;
        // allow +/-n for numeric variables
        if (!strstr(keyword, "authentication") && !strstr(keyword, "map") && ((key = strchr(keyword,'+')) || (key = strchr(keyword,'-'))) && isdigit(*(key+1))) {
          offset = atoi(key);
          *key = 0;
        } else offset = 0;

        if(!strcmp(keyword, "remote_ip")) {
          dest += sprintf(dest, "%s", remote_ip_escaped);
        } else if(!strcmp(keyword, "remote_port")) {
          dest += sprintf(dest, "%u", remote_port + offset);
        } else if(!strcmp(keyword, "transport")) {
          dest += sprintf(dest, "%s", TRANSPORT_TO_STRING(transport));
        } else if(!strcmp(keyword, "local_ip")) {
          dest += sprintf(dest, "%s", local_ip_escaped);
        } else if(!strcmp(keyword, "local_ip_type")) {
          dest += sprintf(dest, "%s", (local_ip_is_ipv6 ? "6" : "4"));
        } else if(!strcmp(keyword, "local_port")) {
          if((transport == T_UDP) && (multisocket) && (toolMode != MODE_SERVER)) {
            dest += sprintf(dest, "%u", call_port + offset);
          } else {
            dest += sprintf(dest, "%u", local_port + offset);
          }
        } else if(!strcmp(keyword, "server_ip")) {
          struct sockaddr_storage server_sockaddr;
          sipp_socklen_t len = SOCK_ADDR_SIZE(&server_sockaddr);
          getsockname(call_socket,
                (sockaddr *)(void *)&server_sockaddr,
                &len);
          if (server_sockaddr.ss_family == AF_INET6) {
            char * temp_dest;
            temp_dest = (char *) malloc(INET6_ADDRSTRLEN);
            memset(temp_dest,0,INET6_ADDRSTRLEN);
            inet_ntop(AF_INET6, 
                      &((_RCAST(struct sockaddr_in6 *,&server_sockaddr))->sin6_addr),
                      temp_dest,
                      INET6_ADDRSTRLEN); 
            dest += sprintf(dest, "%s",temp_dest);
          } else {
            dest += sprintf(dest, "%s", 
            inet_ntoa((_RCAST(struct sockaddr_in *,&server_sockaddr))->sin_addr));
          }          
        } else if(!strcmp(keyword, "media_ip")) {
          dest += sprintf(dest, "%s", media_ip_escaped);
#ifdef PCAPPLAY
        } else if (!strcmp(keyword, "auto_media_port")) {
          /* to make media ports begin from true media_port exported from sipp.cpp, as number begins to 1
           * * 4 to allow video (audio+rtcp+video+rtcp)
           * Modulo 10000 to limit the port number
           * -> Max 10000 concurrent RTP sessions for pcap_play 
           */
          int port = media_port + (4 * (number - 1)) % 10000 + offset;
          if (strstr(current_line, "m=audio ")) {
            if (media_ip_is_ipv6) {
              (_RCAST(struct sockaddr_in6 *, &(play_args_a.from)))->sin6_port = port;
            } else {
              (_RCAST(struct sockaddr_in *, &(play_args_a.from)))->sin_port = port;
            }
          } else if (strstr(current_line, "m=video ")) {
          if (media_ip_is_ipv6) {
              (_RCAST(struct sockaddr_in6 *, &(play_args_v.from)))->sin6_port = port;
          } else {
              (_RCAST(struct sockaddr_in *, &(play_args_v.from)))->sin_port = port;
            }
          } else {
            ERROR_P1("auto_media_port keyword with no audio or video on the current line (%s)", current_line);
          }
          dest += sprintf(dest, "%u", port);
#endif
        } else if(!strcmp(keyword, "media_port")) {
          int port = media_port + offset;
#ifdef PCAPPLAY
          if (strstr(current_line, "audio")) {
            if (media_ip_is_ipv6) {
              (_RCAST(struct sockaddr_in6 *, &(play_args_a.from)))->sin6_port = port;
            } else {
              (_RCAST(struct sockaddr_in *, &(play_args_a.from)))->sin_port = port;
            }
          } else if (strstr(current_line, "video")) {
          if (media_ip_is_ipv6) {
              (_RCAST(struct sockaddr_in6 *, &(play_args_v.from)))->sin6_port = port;
            } else {
              (_RCAST(struct sockaddr_in *, &(play_args_v.from)))->sin_port = port;
            }
          } else {
            ERROR_P1("media_port keyword with no audio or video on the current line (%s)", current_line);
          }
#endif
          dest += sprintf(dest, "%u", port);
        } else if(!strcmp(keyword, "media_ip_type")) {
          dest += sprintf(dest, "%s", (media_ip_is_ipv6 ? "6" : "4"));
        } else if(!strcmp(keyword, "call_number")) {
          dest += sprintf(dest, "%lu", number);
        } else if(!strcmp(keyword, "call_id")) {
          dest += sprintf(dest, "%s", id);
        } else if(!strcmp(keyword, "cseq")) {
          dest += sprintf(dest, "%u", cseq +offset);
        } else if(!strcmp(keyword, "pid")) {
          dest += sprintf(dest, "%u", pid);
        } else if(!strcmp(keyword, "service")) {
          dest += sprintf(dest, "%s", service);
        } else if(!strncmp(keyword, "field", 5)) {
            char* local_dest = dest;
            getFieldFromInputFile(keyword, m_localLineNumber, dest);
            if (dest == local_dest && ('\r' == *(local_dest-1) || '\n' == *(local_dest-1))) {
                /* If the line begins with a field value and there
                 * is nothing to add for this field, 
                 * Jump to the end of line in scenario. SN 
                 */
                while((*src) && (*src != '\n')) {
                    src++;
                }
                if(*src == '\n') {
                    src++;
                }
            }
        } else if(!strcmp(keyword, "peer_tag_param")) {
          if(peer_tag) {
            dest += sprintf(dest, ";tag=%s", peer_tag);
          }
        } else if(strstr(keyword, "tdmmap")) {
          /* keyword to generate c= line for TDM 
           * format: g.h.i/j                    
           * g: varies in interval a, offset x
           * h: fix value
           * i: varies in interval b, offset y
           * j: varies in interval c, offset z
           * Format: tdmmap{1-3}{0}{0-27}{1-24}
           */
           if (!use_tdmmap) 
             ERROR("[tdmmap] keyword without -tdmmap parameter on command line");
           dest += sprintf(dest, "%d.%d.%d/%d", 
                                  tdm_map_x+(int((tdm_map_number)/((tdm_map_b+1)*(tdm_map_c+1))))%(tdm_map_a+1),
                                  tdm_map_h,
                                  tdm_map_y+(int((tdm_map_number)/(tdm_map_c+1)))%(tdm_map_b+1),
                                  tdm_map_z+(tdm_map_number)%(tdm_map_c+1)
                                  );
        } else if(strstr(keyword, "$")) {
          int varId = atoi(keyword+1);
          if(varId < SCEN_VARIABLE_SIZE) {
            if(M_callVariableTable[varId] != NULL) {
              if(M_callVariableTable[varId]->isSet()) {
                dest += sprintf(dest, "%s",
                                M_callVariableTable[varId]->
                                getMatchingValue());
                // WARNING_P1("VARIABLE --%s--", M_callVariableTable[varId]->getMatchingValue());
              } else {
                dest += sprintf(dest, "%s", "");
              }
            }
          }
        } else if(strstr(keyword, "last_")) {
          char * last_header = get_last_header(keyword+5);
          if(last_header) {
            dest += sprintf(dest, "%s", last_header);
          } else {
            /* Jump to the end of line in scenario if nothing
             * to insert in place of this header. */
            while((*src) && (*src != '\n')) {
              src++;
            }
            if(*src == '\n') {
              src++;
            }
          }
        } else if(strstr(keyword, "routes")) {
            if (dialog_route_set) {
                dest += sprintf(dest, "Route: %s", dialog_route_set);
            }
#ifdef _USE_OPENSSL
        } else if(strstr(keyword, "authentication")) {
            /* This keyword is substituted below */
            dest += sprintf(dest, "[%s]", keyword);
#endif
        } else if(strstr(keyword, "branch")) {
          /* Branch is magic cookie + call number + message index in scenario */
          dest += sprintf(dest, "z9hG4bK-%u-%lu-%d", pid, number, P_index);
        } else if(strstr(keyword, "msg_index")) {
          /* Message index in scenario */
          dest += sprintf(dest, "%d", P_index);
        } else if(strstr(keyword, "next_url")) {
          if (next_req_url) {
            dest += sprintf(dest, "%s", next_req_url);
          }
        } else if(strstr(keyword, "len")) {
            length_marker = dest;
            dest += sprintf(dest, "    ");
            len_offset = offset;
        } else {   // scan for the generic parameters - must be last test
          int i = 0;
          while (generic[i]) {
            char *msg1 = *generic[i];
            char *msg2 = *(generic[i] + 1);
            if(!strcmp(keyword, msg1)) {
              dest += sprintf(dest, "%s", msg2);
              break;
            }
            ++i;
          }
          if (!generic[i]) {
            ERROR_P1("Unsupported keyword '%s' in xml scenario file",
                   keyword);
          }
        }
      /* This could also be done at XML parsing time. */
      } else if (*src == '\n') {
        *dest++ = '\r';
        *dest++ = *src++;
        current_line[0] = '\0';
      } else {
        *dest++ = *src++;
      }
    }
    *dest = 0;

#ifdef _USE_OPENSSL
    /* 
     * The authentication substitution must be done outside the above
     * loop