git.maemo.org Git - pkg-perl/blob - deb-src/libnet-libidn-perl/libnet-libidn-perl-0.07/LibIDN.xs

   1 #include "EXTERN.h"
   2 #include "perl.h"
   3 #include "XSUB.h"
   4
   5 #include <idna.h>
   6 #include <punycode.h>
   7 #include <stringprep.h>
   8
   9 #ifdef HAVE_TLD
  10 #include <tld.h>
  11 #endif
  12
  13 #define MAX_DNSLEN 4096
  14
  15 static char * default_charset= "ISO-8859-1";
  16
  17 char *
  18 idn_prep(char * string, char * charset, char * profile)
  19 {
  20         char * output = NULL;
  21         char * res_str = NULL;
  22         char * utf8 = NULL;
  23         int res;
  24
  25     utf8 = stringprep_convert(string, "UTF-8", charset);
  26         if (!utf8)
  27                 return NULL;
  28
  29         res = stringprep_profile(utf8, &output, profile, 0);
  30         free(utf8);
  31
  32         if( (res != STRINGPREP_OK) || !output)
  33                 return NULL;
  34
  35         res_str = stringprep_convert(output, charset, "UTF-8");
  36         free(output);
  37
  38         return res_str;
  39 }
  40
  41 static double
  42 constant(char *name, int len, int arg)
  43 {
  44         errno = 0;
  45         if (0 + 5 >= len )
  46         {
  47                 errno = EINVAL;
  48                 return 0;
  49         }
  50         switch (name[0 + 5])
  51         {
  52                 case 'A':
  53                 if (strEQ(name + 0, "IDNA_ALLOW_UNASSIGNED"))
  54                 {
  55                         return IDNA_ALLOW_UNASSIGNED;
  56                 }
  57     case 'U':
  58                 if (strEQ(name + 0, "IDNA_USE_STD3_ASCII_RULES"))
  59                 {
  60                         return IDNA_USE_STD3_ASCII_RULES;
  61                 }
  62         }
  63         errno = EINVAL;
  64         return 0;
  65 }
  66
  67 MODULE = Net::LibIDN            PACKAGE = Net::LibIDN
  68
  69
  70 double
  71 constant(sv,arg)
  72     PREINIT:
  73         STRLEN          len;
  74     INPUT:
  75         SV *            sv
  76         char *          s = SvPV(sv, len);
  77         int             arg
  78     CODE:
  79         RETVAL = constant(s,len,arg);
  80     OUTPUT:
  81         RETVAL
  82
  83
  84 char *
  85 idn_to_ascii(string, charset=default_charset, flags=0)
  86                 char *  string
  87                 char *  charset
  88                 int flags
  89         PROTOTYPE: $;$$
  90         PREINIT:
  91                 char *  utf8_str = NULL;
  92                 char *  tmp_str = NULL;
  93                 int             res;
  94         CODE:
  95                 utf8_str = stringprep_convert(string, "UTF-8", charset);
  96                 if (utf8_str)
  97                 {
  98                         res = idna_to_ascii_8z(utf8_str, &tmp_str, flags);
  99                         free(utf8_str);
 100                 }
 101                 else
 102                 {
 103                         XSRETURN_UNDEF;
 104                 }
 105                 if (res!=IDNA_SUCCESS)
 106                 {
 107                         XSRETURN_UNDEF;
 108                 }
 109                 RETVAL = tmp_str;
 110         OUTPUT:
 111                 RETVAL
 112         CLEANUP:
 113                 if (tmp_str)
 114                         free(tmp_str);
 115
 116
 117 char *
 118 idn_to_unicode(string, charset=default_charset, flags=0)
 119                 char *  string
 120                 char *  charset
 121                 int flags;
 122         PROTOTYPE: $;$$
 123         PREINIT:
 124                 char *  tmp_str = NULL;
 125                 char *  res_str = NULL;
 126                 int             res;
 127         CODE:
 128                 res = idna_to_unicode_8z8z(string, &tmp_str, flags);
 129                 if(res != IDNA_SUCCESS)
 130                 {
 131                         XSRETURN_UNDEF;
 132                 }
 133                 if (tmp_str)
 134                 {
 135                         res_str = stringprep_convert(tmp_str, charset, "UTF-8");
 136                         free(tmp_str);
 137                 }
 138                 else
 139                 {
 140                         XSRETURN_UNDEF;
 141                 }
 142                 if (!res_str)
 143                 {
 144                         XSRETURN_UNDEF;
 145                 }
 146                 RETVAL = res_str;
 147         OUTPUT:
 148                 RETVAL
 149         CLEANUP:
 150                 free(res_str);
 151
 152
 153 char *
 154 idn_punycode_encode(string, charset=default_charset)
 155                 char *  string
 156                 char *  charset
 157         PROTOTYPE: $;$
 158         PREINIT:
 159                 char *          utf8_str = NULL;
 160                 uint32_t *      q = NULL;
 161                 size_t          len,len2;
 162                 char *          tmp_str = NULL;
 163                 char *          res_str = NULL;
 164                 int                     res;
 165         CODE:
 166                 utf8_str = stringprep_convert(string, "UTF-8", charset);
 167                 if (utf8_str)
 168                 {
 169                         q = stringprep_utf8_to_ucs4(utf8_str, -1, &len);
 170                         free(utf8_str);
 171                 }
 172                 else
 173                 {
 174                         XSRETURN_UNDEF;
 175                 }
 176
 177                 if (!q)
 178                 {
 179                         XSRETURN_UNDEF;
 180                 }
 181
 182                 tmp_str = malloc(MAX_DNSLEN*sizeof(char));
 183                 len2 = MAX_DNSLEN-1;
 184                 res = punycode_encode(len, q, NULL, &len2, tmp_str);
 185                 free(q);
 186
 187                 if (res != PUNYCODE_SUCCESS)
 188                 {
 189                         XSRETURN_UNDEF;
 190                 }
 191
 192                 tmp_str[len2] = '\0';
 193
 194                 res_str = stringprep_convert(tmp_str, charset, "UTF-8");
 195                 free(tmp_str);
 196                 if (!res_str)
 197                 {
 198                         XSRETURN_UNDEF;
 199                 }
 200                 RETVAL = res_str;
 201         OUTPUT:
 202                 RETVAL
 203         CLEANUP:
 204                 free(res_str);
 205
 206
 207 char *
 208 idn_punycode_decode(string, charset=default_charset)
 209                 char *  string
 210                 char *  charset;
 211         PROTOTYPE: $;$
 212         PREINIT:
 213                 char *          utf8_str = NULL;
 214                 uint32_t *      q = NULL;
 215                 size_t          len;
 216                 char *          res_str = NULL;
 217                 int                     res;
 218         CODE:
 219                 len = MAX_DNSLEN-1;
 220                 q = (uint32_t *) malloc(MAX_DNSLEN * sizeof(q[0]));
 221
 222                 if (q)
 223                 {
 224                         res = punycode_decode(strlen(string), string, &len, q, NULL );
 225                 }
 226                 else
 227                 {
 228                         XSRETURN_UNDEF;
 229                 }
 230                 if (res != PUNYCODE_SUCCESS)
 231                 {
 232                         XSRETURN_UNDEF;
 233                 }
 234                 q[len] = '\0';
 235
 236                 utf8_str = stringprep_ucs4_to_utf8(q, -1, NULL, NULL);
 237                 free(q);
 238
 239                 if (utf8_str)
 240                 {
 241                         res_str = stringprep_convert(utf8_str, charset, "UTF-8");
 242                         free(utf8_str);
 243                 }
 244                 else
 245                 {
 246                         XSRETURN_UNDEF;
 247                 }
 248
 249                 if (!res_str)
 250                 {
 251                         XSRETURN_UNDEF;
 252                 }
 253                 RETVAL = res_str;
 254         OUTPUT:
 255                 RETVAL
 256         CLEANUP:
 257                 free(res_str);
 258
 259
 260 char *
 261 idn_prep_name(string, charset=default_charset)
 262                 char *  string
 263                 char *  charset;
 264         PROTOTYPE: $;$
 265         PREINIT:
 266                 char *  res_str = NULL;
 267         CODE:
 268                 res_str = idn_prep(string, charset, "Nameprep");
 269                 if (!res_str)
 270                 {
 271                         XSRETURN_UNDEF;
 272                 }
 273                 RETVAL = res_str;
 274         OUTPUT:
 275                 RETVAL
 276         CLEANUP:
 277                 free(res_str);
 278
 279
 280 char *
 281 idn_prep_kerberos5(string, charset=default_charset)
 282                 char *  string
 283                 char *  charset
 284         PROTOTYPE: $;$
 285         PREINIT:
 286                 char *  res_str = NULL;
 287         CODE:
 288                 res_str = idn_prep(string, charset, "KRBprep");
 289                 if (!res_str)
 290                 {
 291                         XSRETURN_UNDEF;
 292                 }
 293                 RETVAL = res_str;
 294         OUTPUT:
 295                 RETVAL
 296         CLEANUP:
 297                 free(res_str);
 298
 299 char *
 300 idn_prep_node(string, charset=default_charset)
 301                 char *  string
 302                 char *  charset
 303         PROTOTYPE: $;$
 304         PREINIT:
 305                 char *  res_str = NULL;
 306         CODE:
 307                 res_str = idn_prep(string, charset, "Nodeprep");
 308                 if (!res_str)
 309                 {
 310                         XSRETURN_UNDEF;
 311                 }
 312                 RETVAL = res_str;
 313         OUTPUT:
 314                 RETVAL
 315         CLEANUP:
 316                 free(res_str);
 317
 318
 319 char *
 320 idn_prep_resource(string, charset=default_charset)
 321                 char *  string
 322                 char *  charset
 323         PROTOTYPE: $;$
 324         PREINIT:
 325                 char *  res_str = NULL;
 326         CODE:
 327                 res_str = idn_prep(string, charset, "Resourceprep");
 328                 if (!res_str)
 329                 {
 330                         XSRETURN_UNDEF;
 331                 }
 332                 RETVAL = res_str;
 333         OUTPUT:
 334                 RETVAL
 335         CLEANUP:
 336                 free(res_str);
 337
 338
 339 char *
 340 idn_prep_plain(string, charset=default_charset)
 341                 char *  string
 342                 char *  charset
 343         PROTOTYPE: $;$
 344         PREINIT:
 345                 char *  res_str = NULL;
 346         CODE:
 347                 res_str = idn_prep(string, charset, "plain");
 348                 if (!res_str)
 349                 {
 350                         XSRETURN_UNDEF;
 351                 }
 352                 RETVAL = res_str;
 353         OUTPUT:
 354                 RETVAL
 355         CLEANUP:
 356                 free(res_str);
 357
 358
 359 char *
 360 idn_prep_trace(string, charset=default_charset)
 361                 char *  string
 362                 char *  charset
 363         PROTOTYPE: $;$
 364         PREINIT:
 365                 char *  res_str = NULL;
 366         CODE:
 367                 res_str = idn_prep(string, charset, "trace");
 368                 if (!res_str)
 369                 {
 370                         XSRETURN_UNDEF;
 371                 }
 372                 RETVAL = res_str;
 373         OUTPUT:
 374                 RETVAL
 375         CLEANUP:
 376                 free(res_str);
 377
 378
 379 char *
 380 idn_prep_sasl(string, charset=default_charset)
 381                 char *  string
 382                 char *  charset
 383         PROTOTYPE: $;$
 384         PREINIT:
 385                 char *  res_str = NULL;
 386         CODE:
 387                 res_str = idn_prep(string, charset, "SASLprep");
 388                 if (!res_str)
 389                 {
 390                         XSRETURN_UNDEF;
 391                 }
 392                 RETVAL = res_str;
 393         OUTPUT:
 394                 RETVAL
 395         CLEANUP:
 396                 free(res_str);
 397
 398
 399 char *
 400 idn_prep_iscsi(string, charset=default_charset)
 401                 char *  string
 402                 char *  charset
 403         PROTOTYPE: $;$
 404         PREINIT:
 405                 char *          res_str = NULL;
 406         CODE:
 407                 res_str = idn_prep(string, charset, "ISCSIprep");
 408                 if (!res_str)
 409                 {
 410                         XSRETURN_UNDEF;
 411                 }
 412                 RETVAL = res_str;
 413         OUTPUT:
 414                 RETVAL
 415         CLEANUP:
 416                 free(res_str);
 417
 418
 419 #ifdef HAVE_TLD
 420
 421 int
 422 tld_check(string, errpos,  ...)
 423                 char *string
 424                 size_t errpos
 425         PROTOTYPE: $$;$$
 426         PREINIT:
 427                 STRLEN  c_len;
 428                 char * charset = default_charset;
 429                 char * tld = NULL;
 430                 const Tld_table * tld_table = NULL;
 431                 uint32_t *q;
 432                 size_t len;
 433                 char * utf8_str = NULL;
 434                 char * tmp_str = NULL;
 435                 int res;
 436         CODE:
 437                 if (items>2)
 438                 {
 439                         if (ST(2) != &PL_sv_undef)
 440                                 charset = (char*)SvPV(ST(2), c_len);
 441                 }
 442                 if (items>3)
 443                 {
 444                         tld =  (char*)SvPV(ST(3), c_len);
 445                         tld_table = tld_default_table(tld, NULL);
 446                 }
 447                 utf8_str = stringprep_convert(string, "UTF-8", charset);
 448                 if (!utf8_str)
 449                 {
 450                         XSRETURN_UNDEF;
 451                 }
 452                 res = stringprep_profile(utf8_str, &tmp_str, "Nameprep", 0);
 453                 free(utf8_str);
 454                 if (res != STRINGPREP_OK)
 455                 {
 456                         XSRETURN_UNDEF;
 457                 }
 458                 if (tld)
 459                 {
 460                         q = stringprep_utf8_to_ucs4(tmp_str, -1, &len);
 461                         free(tmp_str);
 462                         if (!q)
 463                         {
 464                                 XSRETURN_UNDEF;
 465                         }
 466                         res = tld_check_4t(q, len, &errpos, tld_table);
 467                         free(q);
 468                 }
 469                 else
 470                 {
 471                         res = tld_check_8z(tmp_str, &errpos, NULL);
 472                         free(tmp_str);
 473                 }
 474                 if (res == TLD_SUCCESS)
 475                 {
 476                         RETVAL = 1;
 477                 }
 478                 else if (res == TLD_INVALID)
 479                 {
 480                         RETVAL = 0;
 481                 }
 482                 else
 483                 {
 484                         XSRETURN_UNDEF;
 485                 }
 486         OUTPUT:
 487                 RETVAL
 488                 errpos
 489
 490 char *
 491 tld_get(string)
 492                 char *string
 493         PROTOTYPE: $
 494         PREINIT:
 495                 char *res_str = NULL;
 496                 int res;
 497         CODE:
 498                 res = tld_get_z(string, &res_str);
 499                 if (res == TLD_SUCCESS)
 500                 {
 501                         RETVAL = res_str;
 502                 }
 503                 else
 504                 {
 505                         XSRETURN_UNDEF;
 506                 }
 507         OUTPUT:
 508                 RETVAL
 509         CLEANUP:
 510                 free(res_str);
 511
 512
 513 SV *
 514 tld_get_table(tld)
 515                 char * tld
 516         PROTOTYPE: $
 517         PREINIT:
 518                 const Tld_table * tld_table = NULL;
 519                 HV * rh, * reh;
 520                 AV * ra;
 521                 const Tld_table_element *e;
 522                 size_t pos;
 523         CODE:
 524                 tld_table = tld_default_table(tld, NULL);
 525                 if (tld_table)
 526                 {
 527                         rh = (HV *)sv_2mortal((SV *)newHV());
 528                         hv_store(rh, "name", 4, newSVpv(tld_table->name, 0), 0);
 529                         hv_store(rh, "version", 7, newSVpv(tld_table->version, 0), 0);
 530                         hv_store(rh, "nvalid", 6, newSVuv(tld_table->nvalid), 0);
 531                         ra = (AV *)sv_2mortal((SV *)newAV());
 532                         for (pos=0, e = tld_table->valid; pos<tld_table->nvalid; pos++,e++)
 533                         {
 534                                 reh = (HV *)sv_2mortal((SV *)newHV());
 535                                 hv_store(reh, "start", 5, newSVuv(e->start), 0);
 536                                 hv_store(reh, "end", 3, newSVuv(e->end), 0);
 537                                 av_push(ra, newRV((SV *)reh));
 538                         }
 539                         hv_store(rh, "valid", 5, newRV((SV*)ra), 0);
 540                         RETVAL = newRV((SV*)rh);
 541                 }
 542                 else
 543                 {
 544                         XSRETURN_UNDEF;
 545                 }
 546         OUTPUT:
 547                 RETVAL
 548
 549 #endif /* #ifdef HAVE_TLD */