sip_parse.c

VoIP use SIP protocol interface

				sip_free_cftr_header(parsed_header);
				return (EPROTO);
			}
			value->sip_value_state = SIP_VALUE_BAD;
			goto get_next_cftr_value;
		}

		value->cftr_uri.sip_str_ptr = tmp_ptr;
		value->cftr_uri.sip_str_len =
		    sip_header->sip_hdr_current - tmp_ptr;

		if (sip_find_token(sip_header, '>') != 0) {
			if (sip_goto_next_value(sip_header) != 0) {
				sip_free_cftr_header(parsed_header);
				return (EINVAL);
			}
			value->sip_value_state = SIP_VALUE_BAD;
			goto get_next_cftr_value;
		}

		if (value->cftr_uri.sip_str_len <= strlen("<>")) {
			if (sip_goto_next_value(sip_header) != 0) {
				sip_free_cftr_header(parsed_header);
				return (EPROTO);
			}
			value->sip_value_state = SIP_VALUE_BAD;
			goto get_next_cftr_value;
		}

get_params:
		ret = sip_parse_params(sip_header, &value->sip_param_list);
		if (ret == EPROTO) {
			value->sip_value_state = SIP_VALUE_BAD;
		} else if (ret != 0) {
			sip_free_cftr_header(parsed_header);
			return (ret);
		}
get_next_cftr_value:
		value->sip_value_end = sip_header->sip_hdr_current;

		/*
		 * Parse uri
		 */
		if (value->cftr_uri.sip_str_len > 0) {
			int		error;

			value->sip_value_parsed_uri = sip_parse_uri(
			    &value->cftr_uri, &error);
			if (value->sip_value_parsed_uri == NULL) {
				sip_free_cftr_header(parsed_header);
				return (ENOMEM);
			}
			if (error != 0 ||
			    ((_sip_uri_t *)value->sip_value_parsed_uri)->
			    sip_uri_errflags != 0) {
				value->sip_value_state = SIP_VALUE_BAD;
			}
		}

		(void) sip_find_token(sip_header, SIP_COMMA);
		last_value = value;
		(void) sip_skip_white_space(sip_header);
	}

	sip_header->sip_hdr_parsed = parsed_header;

	*header = parsed_header;
	return (0);
}

/*
 * Parse RAck header
 * "RAck" HCOLON response-num LWS CSeq-num LWS Method
 * response-num  =  1*DIGIT
 * CSeq-num      =  1*DIGIT
 */
int
sip_parse_rack(_sip_header_t *sip_header, sip_parsed_header_t **header)
{
	sip_parsed_header_t	*parsed_header;
	sip_hdr_value_t		*rack_value;
	int			len;
	char			*tmp_ptr;
	int			i;

	if (sip_header == NULL || header == NULL)
		return (EINVAL);
	/* check if previously parsed */
	if (sip_header->sip_hdr_parsed != NULL) {
		*header = sip_header->sip_hdr_parsed;
		return (0);
	}

	*header = NULL;
	parsed_header = calloc(1, sizeof (sip_parsed_header_t));
	if (parsed_header == NULL)
		return (ENOMEM);
	parsed_header->sip_parsed_header_version = SIP_PARSED_HEADER_VERSION_1;

	if (sip_parse_goto_values(sip_header) != 0) {
		free(parsed_header);
		return (EPROTO);
	}

	parsed_header->value =  calloc(1, sizeof (sip_hdr_value_t));
	if (parsed_header->value == NULL) {
		free(parsed_header);
		return (ENOMEM);
	}

	parsed_header->sip_header = sip_header;
	rack_value = (sip_hdr_value_t *)parsed_header->value;
	rack_value->sip_value_version = SIP_VALUE_VERSION_1;
	rack_value->sip_value_start = sip_header->sip_hdr_current;
	rack_value->sip_value_header = parsed_header;
	if (sip_atoi(sip_header, &rack_value->rack_resp) ||
	    rack_value->rack_resp == 0) {
		rack_value->sip_value_state = SIP_VALUE_BAD;
		rack_value->sip_value_end = sip_header->sip_hdr_end - 2;
		goto rack_parse_done;
	}
	rack_value->sip_value_header = parsed_header;
	/*
	 * Get cseq.
	 */
	if (sip_skip_white_space(sip_header) != 0) {
		rack_value->sip_value_state = SIP_VALUE_BAD;
		rack_value->sip_value_end = sip_header->sip_hdr_end - 2;
		goto rack_parse_done;
	}
	if (sip_atoi(sip_header, &rack_value->rack_cseq)) {
		rack_value->sip_value_state = SIP_VALUE_BAD;
		rack_value->sip_value_end = sip_header->sip_hdr_end - 2;
		goto rack_parse_done;
	}
	/*
	 * Get method.
	 */
	if (sip_skip_white_space(sip_header) != 0) {
		rack_value->sip_value_state = SIP_VALUE_BAD;
		rack_value->sip_value_end = sip_header->sip_hdr_end - 2;
		goto rack_parse_done;
	}

	tmp_ptr = sip_header->sip_hdr_current;
	if (sip_find_white_space(sip_header)) {
		rack_value->sip_value_state = SIP_VALUE_BAD;
		rack_value->sip_value_end = sip_header->sip_hdr_end - 2;
		goto rack_parse_done;
	}

	len = sip_header->sip_hdr_current - tmp_ptr;

	for (i = 1; i < MAX_SIP_METHODS; i++) {
		if (strncmp(sip_methods[i].name, tmp_ptr, len) == 0)
			break;
	}

	if (i >= MAX_SIP_METHODS) {
		rack_value->sip_value_state = SIP_VALUE_BAD;
		rack_value->sip_value_end = sip_header->sip_hdr_end - 2;
		goto rack_parse_done;
	}

	rack_value->rack_method = i;
	rack_value->sip_value_end = sip_header->sip_hdr_current;

rack_parse_done:
	sip_header->sip_hdr_parsed = parsed_header;

	*header = parsed_header;
	return (0);
}

/* Parse CSeq header */
int
sip_parse_cseq_header(_sip_header_t *sip_header, sip_parsed_header_t **header)
{
	sip_parsed_header_t	*parsed_header;
	sip_hdr_value_t		*cseq_value;
	int			len;
	char			*tmp_ptr;
	int			i;

	if (sip_header == NULL || header == NULL)
		return (EINVAL);
	/* check if previously parsed */
	if (sip_header->sip_hdr_parsed != NULL) {
		*header = sip_header->sip_hdr_parsed;
		return (0);
	}

	*header = NULL;
	parsed_header = calloc(1, sizeof (sip_parsed_header_t));
	if (parsed_header == NULL)
		return (ENOMEM);
	parsed_header->sip_parsed_header_version = SIP_PARSED_HEADER_VERSION_1;

	if (sip_parse_goto_values(sip_header) != 0) {
		free(parsed_header);
		return (EPROTO);
	}

	parsed_header->value =  calloc(1, sizeof (sip_hdr_value_t));
	if (parsed_header->value == NULL) {
		free(parsed_header);
		return (ENOMEM);
	}

	parsed_header->sip_header = sip_header;
	cseq_value = (sip_hdr_value_t *)parsed_header->value;
	cseq_value->sip_value_version = SIP_VALUE_VERSION_1;
	cseq_value->sip_value_start = sip_header->sip_hdr_current;
	if (sip_atoi(sip_header, &cseq_value->cseq_num)) {
		cseq_value->sip_value_state = SIP_VALUE_BAD;
		cseq_value->sip_value_end = sip_header->sip_hdr_end - 2;
		goto cseq_parse_done;
	}
	cseq_value->sip_value_header = parsed_header;
	/*
	 * Get method.
	 */
	if (sip_skip_white_space(sip_header) != 0) {
		cseq_value->sip_value_state = SIP_VALUE_BAD;
		cseq_value->sip_value_end = sip_header->sip_hdr_end - 2;
		goto cseq_parse_done;
	}

	tmp_ptr = sip_header->sip_hdr_current;

	if (sip_find_white_space(sip_header)) {
		cseq_value->sip_value_state = SIP_VALUE_BAD;
		cseq_value->sip_value_end = sip_header->sip_hdr_current;
		goto cseq_parse_done;
	}

	len = sip_header->sip_hdr_current - tmp_ptr;

	for (i = 1; i < MAX_SIP_METHODS; i++) {
		if (strncmp(sip_methods[i].name, tmp_ptr, len) == 0)
			break;
	}

	if (i >= MAX_SIP_METHODS) {
		cseq_value->sip_value_state = SIP_VALUE_BAD;
		cseq_value->sip_value_end = sip_header->sip_hdr_current;
		goto cseq_parse_done;
	}

	cseq_value->cseq_method = i;
	cseq_value->sip_value_end = sip_header->sip_hdr_current;
cseq_parse_done:

	sip_header->sip_hdr_parsed = parsed_header;

	*header = parsed_header;
	return (0);
}

/* Parse Call-Id header */
int
sip_parse_cid_header(_sip_header_t *sip_header, sip_parsed_header_t **header)
{
	int	r;

	r = sip_parse_hdr_parser4(sip_header, header);
	sip_header->sip_hdr_parsed = *header;
	return (r);
}

/* Parse Content-Length header */
int
sip_parse_clen_header(_sip_header_t *sip_header, sip_parsed_header_t **header)
{
	int	r;

	r = sip_parse_hdr_parser2(sip_header, header, SIP_INT_VAL);
	sip_header->sip_hdr_parsed = *header;
	return (r);
}

/*
 * Max-Forwards  =  "Max-Forwards" HCOLON 1*DIGIT
 */
int
sip_parse_maxf_header(_sip_header_t *sip_header, sip_parsed_header_t **header)
{
	int	r;

	r = sip_parse_hdr_parser2(sip_header, header, SIP_INT_VAL);
	sip_header->sip_hdr_parsed = *header;
	return (r);
}

/*
 * Content-Type     =  ( "Content-Type" / "c" ) HCOLON media-type
 * media-type       =  m-type SLASH m-subtype *(SEMI m-parameter)
 * m-type           =  discrete-type / composite-type
 * discrete-type    =  "text" / "image" / "audio" / "video"
 *                     / "application" / extension-token
 * composite-type   =  "message" / "multipart" / extension-token
 * extension-token  =  ietf-token / x-token
 * ietf-token       =  token
 * x-token          =  "x-" token
 * m-subtype        =  extension-token / iana-token
 * iana-token       =  token
 * m-parameter      =  m-attribute EQUAL m-value
 * m-attribute      =  token
 * m-value          =  token / quoted-string
 */
int
sip_parse_ctype_header(_sip_header_t *sip_header, sip_parsed_header_t **header)
{
	int	r;

	r = sip_parse_hdr_parser1(sip_header, header, SIP_SLASH);
	sip_header->sip_hdr_parsed = *header;
	return (r);
}

/* Return the URI in the request startline */
static int
_sip_get_request_uri(_sip_header_t *sip_header, sip_message_type_t *msg_info)
{
	int	size = 0;
	char	*start_ptr;

	if (sip_skip_white_space(sip_header))
		return (1);
	start_ptr = sip_header->sip_hdr_current;

	while (!isspace(*sip_header->sip_hdr_current)) {
		if (sip_header->sip_hdr_current >= sip_header->sip_hdr_end)
			return (1);
		sip_header->sip_hdr_current++;
	}

	size = sip_header->sip_hdr_current - start_ptr;

	msg_info->U.sip_request.sip_request_uri.sip_str_ptr = start_ptr;
	msg_info->U.sip_request.sip_request_uri.sip_str_len = size;
	if (size > 0) {	/* Parse uri */
		int		error;

		msg_info->U.sip_request.sip_parse_uri = sip_parse_uri(
		    &msg_info->U.sip_request.sip_request_uri, &error);
		if (msg_info->U.sip_request.sip_parse_uri == NULL)
			return (1);
	}
	return (0);
}

/* Parse the start line into request/response */
int
sip_parse_first_line(_sip_header_t *sip_header, sip_message_type_t **msg_info)
{
	sip_message_type_t	*sip_msg_info;
	boolean_t		sip_is_request = B_TRUE;
	int			ret;

	if (sip_header == NULL || msg_info == NULL)
		return (EINVAL);

	if (sip_skip_white_space(sip_header) != 0)
		return (EPROTO);

	/* There is nothing, return */
	if (sip_header->sip_hdr_current + strlen(SIP_VERSION) >=
	    sip_header->sip_hdr_end) {
		return (EPROTO);
	}
#ifdef	__solaris__
	assert(mutex_held(&sip_header->sip_hdr_sipmsg->sip_msg_mutex));
#endif
	sip_msg_info = malloc(sizeof (sip_message_type_t));
	if (sip_msg_info == NULL)
		return (ENOMEM);

	/*
	 * lets see if its a request or a response
	 */
	ret = sip_get_protocol_version(sip_header,
	    &sip_msg_info->sip_proto_version);
	if (ret == 0) {
		sip_is_request = B_FALSE;
	} else if (ret == 2) {
		free(sip_msg_info);
		return (EPROTO);
	}

	if (sip_skip_white_space(sip_header) != 0) {
		free(sip_msg_info);
		return (EPROTO);
	}

	if (!sip_is_request) {
		/*
		 * check for status code.
		 */
		if (sip_skip_white_space(sip_header) != 0) {
			free(sip_msg_info);
			return (EPROTO);
		}
		if (sip_header->sip_hdr_current + SIP_SIZE_OF_STATUS_CODE >=
		    sip_header->sip_hdr_end) {
			free(sip_msg_info);
			return (EPROTO);
		}

		if (sip_atoi(sip_header,
		    &sip_msg_info->U.sip_response.sip_response_code)) {
			free(sip_msg_info);
			return (EPROTO);
		}

		if (sip_msg_info->U.sip_response.sip_response_code < 100 ||
		    sip_msg_info->U.sip_response.sip_response_code > 700) {
			free(sip_msg_info);
			return (EPROTO);
		}

		/*
		 * get reason phrase.
		 */
		if (sip_skip_white_space(sip_header) != 0) {
			sip_msg_info->sip_resp_phrase_len = 0;
			sip_msg_info->sip_resp_phrase_ptr = NULL;
		} else {
			sip_msg_info->sip_resp_phrase_ptr =
			    sip_header->sip_hdr_current;
			if (sip_find_cr(sip_header) != 0) {
				free(sip_msg_info);
				return (EPROTO);
			}
			sip_msg_info->sip_resp_phrase_len =
			    sip_header->sip_hdr_current -
			    sip_msg_info->sip_resp_phrase_ptr;
		}
		sip_msg_info->is_request = B_FALSE;
	} else {
		int i;
		/*
		 * It's a request.
		 */
		sip_msg_info->is_request = B_TRUE;
		for (i = 1; i < MAX_SIP_METHODS; i++) {
			if (strncmp(sip_methods[i].name,
			    sip_header->sip_hdr_current,
			    sip_methods[i].len) == 0) {
				sip_msg_info->sip_req_method = i;
				sip_header->sip_hdr_current +=
				    sip_methods[i].len;
				if (!isspace(*sip_header->sip_hdr_current++) ||
				    !isalpha(*sip_header->sip_hdr_current)) {
					free(sip_msg_info);
					return (EPROTO);
				}

				if (_sip_get_request_uri(sip_header,
				    sip_msg_info)) {
					free(sip_msg_info);
					return (EPROTO);
				}

				/*
				 * Get SIP version
				 */
				ret = sip_get_protocol_version(sip_header,
				    &sip_msg_info->sip_proto_version);
				if (ret != 0) {
					free(sip_msg_info);
					return (EPROTO);
				}
				goto done;
			}
		}
		free(sip_msg_info);
		return (EPROTO);
	}
done:
	sip_msg_info->sip_next = *msg_info;
	*msg_info = sip_msg_info;
	return (0);
}

/* We don't do anything for a header we don't understand */
/* ARGSUSED */
int
sip_parse_unknown_header(_sip_header_t *sip_header,
    sip_parsed_header_t **header)
{
	return (EINVAL);
}