usr/src/lib/libsip/common/sip_uri_ui.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <ctype.h>
  30 #include <errno.h>
  31
  32 #include "sip_parse_uri.h"
  33
  34 void
  35 sip_free_parsed_uri(sip_uri_t uri)
  36 {
  37         _sip_uri_t      *_uri;
  38
  39         if (uri == NULL)
  40                 return;
  41
  42         _uri = (_sip_uri_t *)uri;
  43         if (_uri->sip_uri_issip) {
  44                 sip_param_t     *param;
  45                 sip_param_t     *param_next;
  46
  47                 param = _uri->sip_uri_params;
  48                 while (param != NULL) {
  49                         param_next = param->param_next;
  50                         free(param);
  51                         param = param_next;
  52                 }
  53         }
  54         free(_uri);
  55 }
  56
  57 /*
  58  * Parse the URI in uri_str
  59  */
  60 struct sip_uri *
  61 sip_parse_uri(sip_str_t *uri_str, int *error)
  62 {
  63         struct sip_uri  *parsed_uri;
  64
  65         if (error != NULL)
  66                 *error = 0;
  67
  68         if (uri_str == NULL) {
  69                 if (error != NULL)
  70                         *error = EINVAL;
  71                 return (NULL);
  72         }
  73         parsed_uri = calloc(1, sizeof (_sip_uri_t));
  74         if (parsed_uri == NULL) {
  75                 if (error != NULL)
  76                         *error = ENOMEM;
  77                 return (NULL);
  78         }
  79
  80         sip_uri_parse_it(parsed_uri, uri_str);
  81         if (parsed_uri->sip_uri_errflags & SIP_URIERR_MEMORY) {
  82                 free(parsed_uri);
  83                 if (error != NULL)
  84                         *error = ENOMEM;
  85                 return (NULL);
  86         }
  87         if (parsed_uri->sip_uri_errflags != 0 && error != NULL)
  88                 *error = EPROTO;
  89         return ((sip_uri_t)parsed_uri);
  90 }
  91
  92 /*
  93  * Get parsed URI
  94  */
  95 const struct sip_uri *
  96 sip_get_uri_parsed(sip_header_value_t value, int *error)
  97 {
  98         const struct sip_uri    *ret = NULL;
  99
 100         if (error != NULL)
 101                 *error = 0;
 102         if (value == NULL || value->sip_value_parse_uri == NULL ||
 103             value->value_state == SIP_VALUE_DELETED) {
 104                 if (error != NULL)
 105                         *error = EINVAL;
 106                 return (NULL);
 107         }
 108         ret = value->sip_value_parse_uri;
 109         if (ret->sip_uri_errflags != 0 && error != NULL)
 110                 *error = EINVAL;
 111         return ((sip_uri_t)ret);
 112 }
 113
 114 /*
 115  * Return TRUE if this is a SIP URI
 116  */
 117 boolean_t
 118 sip_is_sipuri(const struct sip_uri *uri)
 119 {
 120         _sip_uri_t      *_uri;
 121
 122         if (uri == NULL)
 123                 return (B_FALSE);
 124         _uri = (_sip_uri_t *)uri;
 125         if ((_uri->sip_uri_errflags & SIP_URIERR_SCHEME) == 0 &&
 126             _uri->sip_uri_scheme.sip_str_len > 0 && _uri->sip_uri_issip) {
 127                 return (B_TRUE);
 128         }
 129         return (B_FALSE);
 130 }
 131
 132 /*
 133  * Some common checks
 134  */
 135 static _sip_uri_t *
 136 sip_check_get_param(const struct sip_uri *uri, int *error)
 137 {
 138         if (error != NULL)
 139                 *error = 0;
 140
 141         if (uri == NULL) {
 142                 if (error != NULL)
 143                         *error = EINVAL;
 144                 return (NULL);
 145         }
 146         return ((_sip_uri_t *)uri);
 147 }
 148
 149
 150 /*
 151  * Return the URI scheme
 152  */
 153 const sip_str_t *
 154 sip_get_uri_scheme(const struct sip_uri *uri, int *error)
 155 {
 156         _sip_uri_t      *_uri;
 157
 158         _uri = sip_check_get_param(uri, error);
 159         if (_uri == NULL)
 160                 return (NULL);
 161
 162         if (((_uri->sip_uri_errflags & SIP_URIERR_SCHEME) != 0 ||
 163             _uri->sip_uri_scheme.sip_str_len == 0) && error != NULL) {
 164                 *error = EINVAL;
 165         }
 166         if (_uri->sip_uri_scheme.sip_str_len > 0)
 167                 return (&_uri->sip_uri_scheme);
 168         return (NULL);
 169 }
 170
 171 /*
 172  *  Return user name from URI
 173  */
 174 const sip_str_t *
 175 sip_get_uri_user(const struct sip_uri *uri, int *error)
 176 {
 177         _sip_uri_t      *_uri;
 178
 179         _uri = sip_check_get_param(uri, error);
 180         if (_uri == NULL)
 181                 return (NULL);
 182
 183         if ((_uri->sip_uri_errflags & SIP_URIERR_USER) != 0 && error != NULL)
 184                 *error = EINVAL;
 185         if (uri->sip_uri_user.sip_str_len > 0)
 186                 return (&uri->sip_uri_user);
 187         return (NULL);
 188 }
 189
 190 /*
 191  *  Return password from URI
 192  */
 193 const sip_str_t *
 194 sip_get_uri_password(const struct sip_uri *uri, int *error)
 195 {
 196         _sip_uri_t      *_uri;
 197
 198         _uri = sip_check_get_param(uri, error);
 199         if (_uri == NULL)
 200                 return (NULL);
 201
 202         if ((_uri->sip_uri_errflags & SIP_URIERR_PASS) != 0 && error != NULL)
 203                 *error = EINVAL;
 204         if (_uri->sip_uri_password.sip_str_len > 0)
 205                 return (&_uri->sip_uri_password);
 206         return (NULL);
 207 }
 208
 209 /*
 210  * Get host from the URI
 211  */
 212 const sip_str_t *
 213 sip_get_uri_host(const struct sip_uri *uri, int *error)
 214 {
 215         _sip_uri_t      *_uri;
 216
 217         _uri = sip_check_get_param(uri, error);
 218         if (_uri == NULL)
 219                 return (NULL);
 220
 221         if ((_uri->sip_uri_errflags & SIP_URIERR_HOST) != 0 && error != NULL)
 222                 *error = EINVAL;
 223         if (_uri->sip_uri_host.sip_str_len > 0)
 224                 return (&_uri->sip_uri_host);
 225         return (NULL);
 226 }
 227
 228 /*
 229  * Get port from the URI
 230  */
 231 int
 232 sip_get_uri_port(const struct sip_uri *uri, int *error)
 233 {
 234         _sip_uri_t      *_uri;
 235
 236         _uri = sip_check_get_param(uri, error);
 237         if (_uri == NULL)
 238                 return (0);
 239
 240         if ((_uri->sip_uri_errflags & SIP_URIERR_PORT) != 0) {
 241                 if (error != NULL)
 242                         *error = EINVAL;
 243                 return (0);
 244         }
 245         return (_uri->sip_uri_port);
 246 }
 247
 248 const sip_param_t *
 249 sip_get_uri_params(const struct sip_uri *uri, int *error)
 250 {
 251         _sip_uri_t              *_uri;
 252
 253         _uri = sip_check_get_param(uri, error);
 254         if (_uri == NULL)
 255                 return (NULL);
 256
 257         if (!_uri->sip_uri_issip) {
 258                 if (error != NULL)
 259                         *error = EINVAL;
 260                 return (NULL);
 261         }
 262
 263         if ((_uri->sip_uri_errflags & SIP_URIERR_PARAM) != 0 && error != NULL)
 264                 *error = EINVAL;
 265         return (_uri->sip_uri_params);
 266 }
 267
 268 /*
 269  * Get headers from the URI
 270  */
 271 const sip_str_t *
 272 sip_get_uri_headers(const struct sip_uri *uri, int *error)
 273 {
 274         _sip_uri_t      *_uri;
 275
 276         _uri = sip_check_get_param(uri, error);
 277         if (_uri == NULL)
 278                 return (NULL);
 279
 280         if (!_uri->sip_uri_issip) {
 281                 if (error != NULL)
 282                         *error = EINVAL;
 283                 return (NULL);
 284         }
 285         if ((_uri->sip_uri_errflags & SIP_URIERR_HEADER) != 0 && error != NULL)
 286                 *error = EINVAL;
 287         if (_uri->sip_uri_headers.sip_str_len > 0)
 288                 return (&_uri->sip_uri_headers);
 289         return (NULL);
 290 }
 291
 292 /*
 293  *  Return opaque value for an ABS URI
 294  */
 295 const sip_str_t *
 296 sip_get_uri_opaque(const struct sip_uri *uri, int *error)
 297 {
 298         _sip_uri_t      *_uri;
 299
 300         _uri = sip_check_get_param(uri, error);
 301         if (_uri == NULL)
 302                 return (NULL);
 303
 304         if (_uri->sip_uri_issip) {
 305                 if (error != NULL)
 306                         *error = EINVAL;
 307                 return (NULL);
 308         }
 309         if ((_uri->sip_uri_errflags & SIP_URIERR_OPAQUE) != 0 && error != NULL)
 310                 *error = EINVAL;
 311         if (_uri->sip_uri_opaque.sip_str_len > 0)
 312                 return (&_uri->sip_uri_opaque);
 313         return (NULL);
 314 }
 315
 316 /*
 317  * Return query from an absolute URI
 318  */
 319 const sip_str_t *
 320 sip_get_uri_query(const struct sip_uri *uri, int *error)
 321 {
 322         _sip_uri_t      *_uri;
 323
 324         _uri = sip_check_get_param(uri, error);
 325         if (_uri == NULL)
 326                 return (NULL);
 327
 328         if (_uri->sip_uri_issip) {
 329                 if (error != NULL)
 330                         *error = EINVAL;
 331                 return (NULL);
 332         }
 333         if ((_uri->sip_uri_errflags & SIP_URIERR_QUERY) != 0 && error != NULL)
 334                 *error = EINVAL;
 335         if (_uri->sip_uri_query.sip_str_len > 0)
 336                 return (&_uri->sip_uri_query);
 337         return (NULL);
 338 }
 339
 340 /*
 341  *  Get path from an assolute URI
 342  */
 343 const sip_str_t *
 344 sip_get_uri_path(const struct sip_uri *uri, int *error)
 345 {
 346         _sip_uri_t      *_uri;
 347
 348         _uri = sip_check_get_param(uri, error);
 349         if (_uri == NULL)
 350                 return (NULL);
 351
 352         if (_uri->sip_uri_issip) {
 353                 if (error != NULL)
 354                         *error = EINVAL;
 355                 return (NULL);
 356         }
 357         if ((_uri->sip_uri_errflags & SIP_URIERR_PATH) != 0 && error != NULL)
 358                 *error = EINVAL;
 359         if (_uri->sip_uri_path.sip_str_len > 0)
 360                 return (&_uri->sip_uri_path);
 361         return (NULL);
 362 }
 363
 364 /*
 365  * Get the reg-name from absolute URI
 366  */
 367 const sip_str_t *
 368 sip_get_uri_regname(const struct sip_uri *uri, int *error)
 369 {
 370         _sip_uri_t      *_uri;
 371
 372         _uri = sip_check_get_param(uri, error);
 373         if (_uri == NULL)
 374                 return (NULL);
 375
 376         if (_uri->sip_uri_issip) {
 377                 if (error != NULL)
 378                         *error = EINVAL;
 379                 return (NULL);
 380         }
 381         if ((_uri->sip_uri_errflags & SIP_URIERR_REGNAME) != 0 && error != NULL)
 382                 *error = EINVAL;
 383         if (_uri->sip_uri_regname.sip_str_len > 0)
 384                 return (&_uri->sip_uri_regname);
 385         return (NULL);
 386 }
 387
 388 /*
 389  * Return TRUE if this is a teluser
 390  */
 391 boolean_t
 392 sip_is_uri_teluser(const struct sip_uri *uri)
 393 {
 394         _sip_uri_t      *_uri;
 395
 396         if (uri == NULL)
 397                 return (B_FALSE);
 398
 399         _uri = (_sip_uri_t *)uri;
 400         return (_uri->sip_uri_isteluser);
 401 }
 402
 403 int
 404 sip_get_uri_errflags(const struct sip_uri *uri, int *error)
 405 {
 406         _sip_uri_t      *_uri;
 407
 408         _uri = sip_check_get_param(uri, error);
 409         if (_uri == NULL)
 410                 return (0);
 411         return (_uri->sip_uri_errflags);
 412 }
 413
 414 /*
 415  * the caller is responsible for freeing the returned string
 416  */
 417 char *
 418 sip_uri_errflags_to_str(int errflags)
 419 {
 420         char    *err_info = NULL;
 421
 422         if (errflags == 0)
 423                 return (NULL);
 424
 425         err_info = (char *)malloc(SIP_URI_BUF_SIZE);
 426         if (err_info == NULL)
 427                 return (NULL);
 428
 429         if (errflags & SIP_URIERR_NOURI) {
 430                 (void) strncpy(err_info, "Error : No URI",
 431                     strlen("Error : No URI"));
 432                 err_info[strlen("Error : No URI")] = '\0';
 433                 return (err_info);
 434         }
 435
 436         (void) strncpy(err_info, "Error(s) in", strlen("Error(s) in"));
 437         err_info[strlen("Error(s) in")] = '\0';
 438         if (errflags & SIP_URIERR_SCHEME)
 439                 (void) strncat(err_info, " SCHEME,", strlen(" SCHEME,"));
 440         if (errflags & SIP_URIERR_USER)
 441                 (void) strncat(err_info, " USER,", strlen(" USER,"));
 442         if (errflags & SIP_URIERR_PASS)
 443                 (void) strncat(err_info, " PASSWORD,", strlen(" PASSWORD,"));
 444         if (errflags & SIP_URIERR_HOST)
 445                 (void) strncat(err_info, " HOST,", strlen(" HOST,"));
 446         if (errflags & SIP_URIERR_PORT)
 447                 (void) strncat(err_info, " PORT,", strlen(" PORT,"));
 448         if (errflags & SIP_URIERR_PARAM) {
 449                 (void) strncat(err_info, " PARAMETERS,",
 450                     strlen(" PARAMETERS,"));
 451         }
 452         if (errflags & SIP_URIERR_HEADER)
 453                 (void) strncat(err_info, " HEADERS,", strlen(" HEADERS,"));
 454         if (errflags & SIP_URIERR_OPAQUE)
 455                 (void) strncat(err_info, " OPAQUE,", strlen(" OPAQUE,"));
 456         if (errflags & SIP_URIERR_QUERY)
 457                 (void) strncat(err_info, " QUERY,", strlen(" QUERY,"));
 458         if (errflags & SIP_URIERR_PATH)
 459                 (void) strncat(err_info, " PATH,", strlen(" PATH,"));
 460         if (errflags & SIP_URIERR_REGNAME)
 461                 (void) strncat(err_info, " REG-NAME,", strlen(" REG-NAME,"));
 462         if (strlen(err_info) == strlen("Error(s) in")) {
 463                 free(err_info);
 464                 err_info = NULL;
 465         } else {
 466                 err_info[strlen(err_info) - 1] = '\0';
 467                 (void) strncat(err_info, " part(s)", strlen(" part(s)"));
 468         }
 469         return (err_info);
 470 }