home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Lib / or / orn-enc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  23.1 KB  |  1,003 lines
  1. /* orn-enc.c: routines to encode ORNames */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Lib/or/RCS/orn-enc.c,v 6.0 1991/12/18 20:23:08 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Lib/or/RCS/orn-enc.c,v 6.0 1991/12/18 20:23:08 jpo Rel $
  9.  *
  10.  * $Log: orn-enc.c,v $
  11.  * Revision 6.0  1991/12/18  20:23:08  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16. #include "util.h"
  17. #include "or.h"
  18. #include "IOB-types.h"
  19. #include "MTA-types.h"
  20. #include "Ext-types.h"
  21. #include "extension.h"
  22. #include <isode/isoaddrs.h>
  23.  
  24. static int build_std_or(), build_dd_or(), build_ext_or();
  25.  
  26. #define STR2QB(s)    str2qb(s, strlen(s), 1)
  27.  
  28. struct type_IOB_ORName    *orn2orname(orn)
  29. ORName    *orn;
  30. {
  31.     struct type_IOB_ORName *orname;
  32.     OR_ptr or;
  33.     int ret;
  34.  
  35.  
  36.     orname = (struct type_IOB_ORName *) smalloc (sizeof *orname);
  37.     bzero ((char *)orname, sizeof *orname);
  38.  
  39.     for (or = orn -> on_or; or; or = or -> or_next) {
  40.         switch (or -> or_type) {
  41.             case OR_C:
  42.             case OR_ADMD:
  43.             case OR_PRMD:
  44.             case OR_X121:
  45.             case OR_TID:
  46.             case OR_UAID:
  47.             ret = build_std_or (&orname -> standard__attributes,
  48.                         or);
  49.             break;
  50.  
  51.             case OR_O:
  52.             case OR_OU:
  53.             case OR_S:
  54.             case OR_G:
  55.             case OR_I:
  56.             case OR_GQ:
  57.             if (or -> or_encoding == OR_ENC_PS)
  58.                 ret = build_std_or (&orname -> standard__attributes,
  59.                             or);
  60.             else if (or -> or_encoding == OR_ENC_TTX)
  61.                 ret = build_ext_or (&orname -> extension__attributes,
  62.                             or);
  63.             else {
  64.                 ret = build_std_or (&orname -> standard__attributes,
  65.                             or);
  66.                 if (ret == OK)
  67.                     ret = build_ext_or (&orname -> extension__attributes,
  68.                                 or);
  69.             }
  70.             break;
  71.             case OR_DD:
  72.             if (or -> or_encoding == OR_ENC_PS)
  73.                 ret = build_dd_or (&orname -> domain__defined,
  74.                             or);
  75.             else if (or -> or_encoding == OR_ENC_TTX)
  76.                 ret = build_ext_or (&orname -> extension__attributes,
  77.                             or);
  78.             else {
  79.                 ret = build_dd_or (&orname -> domain__defined,
  80.                             or);
  81.                 if (ret == OK)
  82.                     ret = build_ext_or (&orname -> extension__attributes,
  83.                                 or);
  84.             }
  85.             break;
  86.             case OR_CN:
  87.             case OR_PDSNAME:
  88.             case OR_PD_C:
  89.             case OR_POSTCODE:
  90.             case OR_PDO_NAME:
  91.             case OR_PDO_NUM:
  92.             case OR_OR_COMPS:
  93.             case OR_PD_PN:
  94.             case OR_PD_O:
  95.             case OR_PD_COMPS:
  96.             case OR_UPA_PA:
  97.             case OR_STREET:
  98.             case OR_PO_BOX:
  99.             case OR_PRA:
  100.             case OR_UPN:
  101.             case OR_LPA:
  102.             case OR_ENA_N:
  103.             case OR_ENA_S:
  104.             case OR_ENA_P:
  105.             case OR_TT:
  106.             ret = build_ext_or (&orname -> extension__attributes,
  107.                         or);
  108.             break;
  109.         }
  110.         if (ret == NOTOK) {
  111.             free_IOB_ORName (orname);
  112.             return NULL;
  113.         }
  114.     }
  115.     if (orname -> standard__attributes == NULL)
  116.            orname -> standard__attributes = 
  117.                (struct type_MTA_StandardAttributes *) calloc
  118.                (1, sizeof (struct type_MTA_StandardAttributes));
  119.  
  120.     if (orn -> on_dn) {
  121.         PE pet;
  122.         if (encode_IF_Name (&orname -> directory__name, 1, NULLCP, 0,
  123.                 orn -> on_dn) == NOTOK) {
  124.             PP_LOG (LLOG_EXCEPTIONS, ("Can't encode DN [%s]",
  125.                           PY_pepy));
  126.             free_IOB_ORName (orname);
  127.             return NULL;
  128.         }
  129.         if ((pet = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS, 0)) ==
  130.             NULLPE) {
  131.             PP_LOG (LLOG_EXCEPTIONS, ("Can't allocate PE"));
  132.             free_IOB_ORName (orname);
  133.             return NULL;
  134.         }
  135.         pet -> pe_cons = orname->directory__name;
  136.         orname->directory__name = pet;
  137.     } else
  138.         orname->directory__name = NULL;
  139.     return orname;
  140. }
  141.  
  142. PE orname2pe(orname)
  143. struct type_IOB_ORName    *orname;
  144. {
  145.     PE    pe;
  146.     if (encode_IOB_ORName (&pe, 1, NULLCP, 0, orname) == NOTOK) {
  147.         PP_LOG (LLOG_EXCEPTIONS, ("Can't encode DN [%s]",
  148.                       PY_pepy));
  149.         return NULLPE;
  150.     }
  151.     return pe;
  152. }
  153.  
  154. PE orn2pe (orn)
  155. ORName *orn;
  156. {
  157.     struct type_IOB_ORName    *orname;
  158.     PE    pe;
  159.     
  160.     if ((orname = orn2orname(orn)) == NULL)
  161.         return NULLPE;
  162.     pe = orname2pe(orname);
  163.     free_IOB_ORName(orname);
  164.     return pe;
  165. }
  166.  
  167. struct type_MTA_ORAddress *ora2oradr (ortree)
  168. OR_ptr ortree;
  169. {
  170.     struct type_MTA_ORAddress *ora;
  171.     OR_ptr or;
  172.     int ret;
  173.  
  174.     ora = (struct type_MTA_ORAddress *) smalloc (sizeof *ora);
  175.     bzero ((char *)ora, sizeof *ora);
  176.  
  177.     for (or = ortree; or; or = or -> or_next) {
  178.         switch (or -> or_type) {
  179.             case OR_C:
  180.             case OR_ADMD:
  181.             case OR_PRMD:
  182.             case OR_X121:
  183.             case OR_TID:
  184.             case OR_UAID:
  185.             ret = build_std_or (&ora -> standard__attributes,
  186.                         or);
  187.             break;
  188.  
  189.             case OR_O:
  190.             case OR_OU:
  191.             case OR_S:
  192.             case OR_G:
  193.             case OR_I:
  194.             case OR_GQ:
  195.             if (or -> or_encoding == OR_ENC_PS)
  196.                 ret = build_std_or (&ora -> standard__attributes,
  197.                             or);
  198.             else if (or -> or_encoding == OR_ENC_TTX)
  199.                 ret = build_ext_or (&ora -> extension__attributes,
  200.                             or);
  201.             else {
  202.                 ret = build_std_or (&ora -> standard__attributes,
  203.                             or);
  204.                 if (ret == OK)
  205.                     ret = build_ext_or (&ora -> extension__attributes,
  206.                                 or);
  207.             }
  208.             break;
  209.             case OR_DD:
  210.             if (or -> or_encoding == OR_ENC_PS)
  211.                 ret = build_dd_or (&ora -> domain__defined__attributes,
  212.                             or);
  213.             else if (or -> or_encoding == OR_ENC_TTX)
  214.                 ret = build_ext_or (&ora -> extension__attributes,
  215.                             or);
  216.             else {
  217.                 ret = build_dd_or (&ora -> domain__defined__attributes,
  218.                             or);
  219.                 if (ret == OK)
  220.                     ret = build_ext_or (&ora -> extension__attributes,
  221.                                 or);
  222.             }
  223.             break;
  224.             case OR_CN:
  225.             case OR_PDSNAME:
  226.             case OR_PD_C:
  227.             case OR_POSTCODE:
  228.             case OR_PDO_NAME:
  229.             case OR_PDO_NUM:
  230.             case OR_OR_COMPS:
  231.             case OR_PD_PN:
  232.             case OR_PD_O:
  233.             case OR_PD_COMPS:
  234.             case OR_UPA_PA:
  235.             case OR_STREET:
  236.             case OR_PO_BOX:
  237.             case OR_PRA:
  238.             case OR_UPN:
  239.             case OR_LPA:
  240.             case OR_ENA_N:
  241.             case OR_ENA_S:
  242.             case OR_ENA_P:
  243.             case OR_TT:
  244.             ret = build_ext_or (&ora -> extension__attributes,
  245.                         or);
  246.             break;
  247.         }
  248.         if (ret == NOTOK) {
  249.             free_MTA_ORAddress (ora);
  250.             return NULL;
  251.         }
  252.     }
  253.     return ora;
  254. }
  255.  
  256. PE oradr2pe(ora)
  257. struct type_MTA_ORAddress *ora;
  258. {
  259.     PE pe;
  260.     if (encode_MTA_ORAddress (&pe, 1, NULLCP, 0, ora) == NOTOK) {
  261.         PP_LOG (LLOG_EXCEPTIONS, ("Can't encode ORAddress [%s]",
  262.                       PY_pepy));
  263.         return NULLPE;
  264.     }
  265.     
  266.     return pe;
  267. }
  268.  
  269. PE ora2pe(ortree)
  270. OR_ptr    ortree;
  271. {
  272.     struct type_MTA_ORAddress    *ora;
  273.     PE    pe;
  274.     if ((ora = ora2oradr(ortree)) == NULL)
  275.         return NULLPE;
  276.     pe = oradr2pe(ora);
  277.     free_MTA_ORAddress(ora);
  278.     return pe;
  279. }
  280.  
  281. static int build_std_or (std, or)
  282. struct type_MTA_StandardAttributes **std;
  283. OR_ptr or;
  284. {
  285.     if (*std == NULL) {
  286.         *std = (struct type_MTA_StandardAttributes *)
  287.             smalloc (sizeof **std);
  288.         bzero ((char *)*std, sizeof **std);
  289.     }
  290.     
  291.     switch (or -> or_type) {
  292.         case OR_C:
  293.         {
  294.             struct type_MTA_CountryName *co;
  295.             if ((*std) -> country__name) {
  296.                 PP_LOG (LLOG_EXCEPTIONS,
  297.                     ("two country attributes"));
  298.                 return NOTOK;
  299.             }
  300.             co = (struct type_MTA_CountryName *)
  301.                 smalloc (sizeof *co);
  302.             if (or_str_isns (or -> or_value)) {
  303.                 co -> offset = type_MTA_CountryName_x121__dcc__code;
  304.                 co -> un.x121__dcc__code =
  305.                     STR2QB(or->or_value);
  306.             }
  307.             else {
  308.                 co -> offset = type_MTA_CountryName_iso__3166__alpha2__code;
  309.                 co -> un.iso__3166__alpha2__code =
  310.                     STR2QB (or -> or_value);
  311.             }
  312.             (*std) -> country__name = co;
  313.         }
  314.         break;
  315.         case OR_ADMD:
  316.         {
  317.             struct type_MTA_AdministrationDomainName *admd;
  318.  
  319.             if ((*std) -> administration__domain__name != NULL) {
  320.                 PP_LOG (LLOG_EXCEPTIONS,
  321.                     ("Already got an ADMD"));
  322.                 return NOTOK;
  323.             }
  324.             admd = (*std) -> administration__domain__name =
  325.                 (struct type_MTA_AdministrationDomainName *)
  326.                     smalloc (sizeof *admd);
  327.             if (or_str_isns (or -> or_value)) {
  328.                 admd -> offset = type_MTA_AdministrationDomainName_numeric;
  329.                 admd -> un.numeric = STR2QB (or -> or_value);
  330.             }
  331.             else {
  332.                 admd -> offset =
  333.                     type_MTA_AdministrationDomainName_printable;
  334.                 admd -> un.printable = STR2QB (or -> or_value);
  335.         }
  336.         }
  337.         break;
  338.             
  339.         case OR_PRMD:
  340.         {
  341.             struct type_MTA_PrivateDomainName *prmd;
  342.  
  343.             if ((*std) -> private__domain__name != NULL ){
  344.                 PP_LOG (LLOG_EXCEPTIONS,
  345.                     ("Already got a PRMD"));
  346.                 return NOTOK;
  347.             }
  348.             prmd = (*std) -> private__domain__name =
  349.                 (struct type_MTA_PrivateDomainName *)
  350.                     smalloc (sizeof *prmd);
  351.             if (or_str_isns (or -> or_value)) {
  352.                 prmd -> offset = type_MTA_PrivateDomainName_numeric;
  353.                 prmd -> un.numeric = STR2QB (or-> or_value);
  354.             }
  355.             else {
  356.                 prmd -> offset = type_MTA_PrivateDomainName_printable;
  357.                 prmd -> un.printable = STR2QB (or-> or_value);
  358.             }
  359.         }
  360.         break;
  361.  
  362.         case OR_O:
  363.         {
  364.             if (or -> or_encoding == OR_ENC_TTX)
  365.                 break;
  366.             if ((*std) -> organization__name != NULL) {
  367.                 PP_LOG (LLOG_EXCEPTIONS,
  368.                     ("Already got an Organization"));
  369.                 return NOTOK;
  370.             }
  371.             (*std) -> organization__name =
  372.                 or_getps (or -> or_value, or->or_encoding);
  373.         }
  374.         break;
  375.         case OR_OU:
  376.         {
  377.             struct type_MTA_OrganizationalUnitNames *ou, **oup;
  378.  
  379.             if (or -> or_encoding == OR_ENC_TTX)
  380.                 break;
  381.             for (oup = &(*std) -> organizational__unit__names;
  382.                  *oup; oup = &(*oup) -> next)
  383.                 continue;
  384.             ou = (struct type_MTA_OrganizationalUnitNames *)
  385.                 smalloc (sizeof *ou);
  386.             ou -> OrganizationUnitName =
  387.                 or_getps (or -> or_value, or -> or_encoding);
  388.             ou -> next = NULL;
  389.             *oup = ou;
  390.         }
  391.         break;
  392.                 
  393.         case OR_X121:
  394.         {
  395.             if ((*std) -> network__address != NULL) {
  396.                 PP_LOG (LLOG_EXCEPTIONS,
  397.                     ("Extra X121 id"));
  398.                 return NOTOK;
  399.             }
  400.             (*std) -> network__address = STR2QB (or -> or_value);
  401.         }
  402.         break;
  403.  
  404.         case OR_TID:
  405.         {
  406.             if ((*std) -> terminal__identifier != NULL) {
  407.                 PP_LOG (LLOG_EXCEPTIONS,
  408.                     ("Extra terminal identifier"));
  409.                 return NOTOK;
  410.             }
  411.             (*std) -> terminal__identifier = STR2QB (or -> or_value);
  412.         }
  413.         break;
  414.  
  415.         case OR_UAID:
  416.         {
  417.             if ((*std) -> numeric__user__identifier != NULL) {
  418.                 PP_LOG (LLOG_EXCEPTIONS,
  419.                     ("extra numeric user id"));
  420.                 return NOTOK;
  421.             }
  422.             (*std) -> numeric__user__identifier =
  423.                 STR2QB (or -> or_value);
  424.         }
  425.         break;
  426.                 
  427.         case OR_S:
  428.         case OR_G:
  429.         case OR_I:
  430.         case OR_GQ:
  431.         {
  432.             struct type_MTA_PersonalName *pn;
  433.  
  434.             if ((*std) -> personal__name == NULL) {
  435.                 pn = (*std) -> personal__name =
  436.                     (struct type_MTA_PersonalName *)
  437.                         smalloc (sizeof *pn);
  438.                 bzero ((char *)pn, sizeof *pn);
  439.             }
  440.             else    pn = (*std) -> personal__name;
  441.  
  442.             switch (or -> or_type) {
  443.                 case OR_S:
  444.                 pn -> surname = or_getps (or -> or_value,
  445.                               or -> or_encoding);
  446.                 break;
  447.  
  448.                 case OR_G:
  449.                 pn -> given__name = or_getps (or -> or_value,
  450.                                   or -> or_encoding);
  451.                 break;
  452.  
  453.                 case OR_I:
  454.                 pn -> initials = or_getps (or -> or_value,
  455.                                or -> or_encoding);
  456.                 break;
  457.  
  458.                 case OR_GQ:
  459.                 pn -> generation__qualifier =
  460.                     or_getps (or -> or_value,
  461.                           or -> or_encoding);
  462.                 break;
  463.             }
  464.         }
  465.         break;
  466.                 
  467.         default:
  468.         PP_LOG (LLOG_EXCEPTIONS, ("Bad type %d", or -> or_type));
  469.         return NOTOK;
  470.     }
  471.     return OK;
  472. }
  473.  
  474. static int build_dd_or (domd, or)
  475. struct type_MTA_DomainDefinedAttributes **domd;
  476. OR_ptr or;
  477. {
  478.     struct type_MTA_DomainDefinedAttributes **ddp, *dp;
  479.  
  480.     for (ddp = domd; *ddp; ddp = &(*ddp) -> next)
  481.         continue;
  482.  
  483.     dp = (struct type_MTA_DomainDefinedAttributes *)
  484.         smalloc (sizeof *dp);
  485.     if (dp == NULL)
  486.         return NOTOK;
  487.     dp -> DomainDefinedAttribute =
  488.         (struct type_MTA_DomainDefinedAttribute *)
  489.             smalloc (sizeof *dp -> DomainDefinedAttribute);
  490.     dp -> next = NULL;
  491.     dp -> DomainDefinedAttribute -> type = STR2QB (or -> or_ddname);
  492.     dp -> DomainDefinedAttribute -> value = STR2QB (or -> or_value);
  493.  
  494.     *ddp = dp;
  495.     return OK;
  496. }
  497.  
  498.  
  499. static int build_aext (or, mod, offset, label, fnx, type, ext)
  500. OR_ptr or;
  501. modtyp *mod;
  502. int offset;
  503. IFP    fnx;
  504. char *label;
  505. struct type_MTA_ExtensionAttributes **ext;
  506. {
  507.     struct type_MTA_ExtensionAttribute *ep;
  508.     struct type_MTA_ExtensionAttributes *epa;
  509.     caddr_t parm;
  510.     PE pe;
  511.  
  512.     if ((*fnx) (or, &parm) == NOTOK)
  513.         return NOTOK;
  514.  
  515.     ep = (struct type_MTA_ExtensionAttribute *) smalloc (sizeof *ep);
  516.     ep -> type = type;
  517.  
  518.     if (enc_f (offset, mod, &pe, 1, 0, NULLCP, parm) == NOTOK) {
  519.         PP_LOG (LLOG_EXCEPTIONS, ("Can't encode value %s: %s",
  520.                       label, PY_pepy));
  521.         return NOTOK;
  522.     }
  523.     /* insert tag */
  524.     ep -> value = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS, 1);
  525.     ep -> value -> pe_cons = pe;
  526. #if PP_DEBUG > 0
  527.         if(pp_log_norm -> ll_events & LLOG_PDUS)
  528.                 pvpdu (pp_log_norm, offset, mod,
  529.                        ep -> value, label, PDU_WRITE);
  530. #endif
  531.         (void) fre_obj (parm, mod->md_dtab[offset], mod, 1);
  532.  
  533.     epa = (struct type_MTA_ExtensionAttributes *) smalloc (sizeof *epa);
  534.     epa -> next = *ext;
  535.     *ext = epa;
  536.     epa -> ExtensionAttribute = ep;
  537.  
  538.     return OK;
  539. }
  540.  
  541. static int ext_ttx_str (or, qb)
  542. OR_ptr or;
  543. struct qbuf **qb;
  544. {
  545.     if ((*qb = or_getttx (or -> or_value, or -> or_encoding)) == NULL)
  546.         return NOTOK;
  547.     return OK;
  548. }
  549.  
  550. static int ext_ps_str (or, qb)
  551. OR_ptr or;
  552. struct qbuf **qb;
  553. {
  554.     if ((*qb = or_getps (or -> or_value, or -> or_encoding)) == NULL)
  555.         return NOTOK;
  556.     return OK;
  557. }
  558.  
  559. static int ext_pdsparm (or, parm)
  560. OR_ptr or;
  561. struct type_Ext_PDSParameter **parm;
  562. {
  563.     *parm = (struct type_Ext_PDSParameter *)
  564.         smalloc (sizeof **parm);
  565.     
  566.     switch (or -> or_encoding) {
  567.         case OR_ENC_TTX_AND_OR_PS:
  568.         (*parm) -> printable__string = or_getps (or -> or_value,
  569.                               or -> or_encoding);
  570.         /* fall */
  571.         case OR_ENC_TTX:
  572.         (*parm) -> teletex__string = or_getttx (or -> or_value,
  573.                              or -> or_encoding);
  574.         return OK;
  575.  
  576.         case OR_ENC_PS:
  577.         (*parm) -> printable__string = or_getps (or -> or_value,
  578.                              or -> or_encoding);
  579.         return OK;
  580.  
  581.         default:
  582.         PP_LOG (LLOG_EXCEPTIONS, ("Unknown encoding type %d for %s",
  583.                       or -> or_encoding, or -> or_value));
  584.         return NOTOK;
  585.     }
  586. }
  587.  
  588. static int ext_upa (or, parm) /* XXX BROKEN */
  589. OR_ptr or;
  590. struct type_Ext_UnformattedPostalAddress **parm;
  591. {
  592.     struct element_Ext_1 **pap;
  593.     *parm = (struct type_Ext_UnformattedPostalAddress *)
  594.         smalloc (sizeof **parm);
  595.     pap = &(*parm)->printable__address;
  596.  
  597.     for (;or && or -> or_type == OR_UPA_PA; or = or -> or_next) {
  598.         switch (or -> or_encoding) {
  599.             case OR_ENC_TTX:
  600.             (*parm) -> teletex__string =
  601.                 or_getttx (or -> or_value,
  602.                        or -> or_encoding);
  603.             break;
  604.             case OR_ENC_PS:
  605.             *pap = (struct element_Ext_1 *)
  606.                 smalloc (sizeof **pap);
  607.             (*pap) -> PrintableString =
  608.                 or_getps (or -> or_value, or -> or_encoding);
  609.             (*pap) -> next = NULL;
  610.             pap = &(*pap) -> next;
  611.             break;
  612.             default:
  613.             PP_LOG (LLOG_EXCEPTIONS,
  614.                 ("Unexpected encoding in UFPA %s %d",
  615.                  or -> or_value, or -> or_encoding));
  616.             return NOTOK;
  617.         }
  618.     }
  619.     return OK;
  620. }
  621.  
  622. static int ext_psorns_str (or, parm)
  623. OR_ptr or;
  624. struct type_Ext_PostalCode **parm;
  625. {
  626.     *parm = (struct type_Ext_PostalCode *)
  627.         smalloc (sizeof **parm);
  628.     switch (or -> or_encoding) {
  629.         case OR_ENC_NUM:
  630.         (*parm) -> offset = type_Ext_PostalCode_numeric__code;
  631.         (*parm) -> un.numeric__code = STR2QB (or -> or_value);
  632.         break;
  633.         case OR_ENC_PS:
  634.         (*parm) -> offset = type_Ext_PostalCode_printable__code;
  635.         (*parm) -> un.printable__code = STR2QB(or -> or_value);
  636.         break;
  637.         default:
  638.         PP_LOG (LLOG_EXCEPTIONS,
  639.             ("Unexpected postalcode encoding %d %s",
  640.              or -> or_encoding, or -> or_value));
  641.         return NOTOK;
  642.     }
  643.     return OK;
  644. }
  645.  
  646. static int ext_ttxous (or, parm)
  647. OR_ptr or;
  648. struct type_Ext_TeletexOrganizationalUnitNames **parm;
  649. {
  650.     for (;or && or -> or_type == OR_OU; or = or -> or_next) {
  651.         if (or -> or_encoding != OR_ENC_TTX &&
  652.             or -> or_encoding != OR_ENC_TTX_AND_OR_PS)
  653.             continue;
  654.         *parm = (struct type_Ext_TeletexOrganizationalUnitNames *)
  655.             smalloc (sizeof **parm);
  656.         (*parm) -> next = NULL;
  657.         (*parm) -> TeletexOrganizationalUnitName =
  658.             or_getttx (or -> or_value,
  659.                    or -> or_encoding);
  660.         parm = &(*parm) -> next;
  661.     }
  662.     return OK;
  663. }
  664.  
  665. static int ext_ttx_pn (or, parm)
  666. OR_ptr or;
  667. struct type_Ext_TeletexPersonalName **parm;
  668. {
  669.     *parm = (struct type_Ext_TeletexPersonalName *)
  670.         smalloc (sizeof **parm);
  671.     while (or) {
  672.         if (or -> or_encoding != OR_ENC_TTX &&
  673.             or -> or_encoding != OR_ENC_TTX_AND_OR_PS)
  674.             continue;
  675.         switch (or -> or_type) {
  676.             case OR_S:
  677.             (*parm) -> surname = or_getttx (or->or_value,
  678.                             or -> or_encoding);
  679.             break;
  680.             case OR_GQ:
  681.             (*parm) -> given__name = or_getttx (or -> or_value,
  682.                                 or -> or_encoding);
  683.             break;
  684.             case OR_I:
  685.             (*parm) -> initials = or_getttx (or -> or_value,
  686.                              or -> or_encoding);
  687.             break;
  688.             case OR_G:
  689.             (*parm) -> generation__qualifier =
  690.                 or_getttx (or -> or_value,
  691.                        or -> or_encoding);
  692.             break;
  693.  
  694.             default:
  695.             return OK;
  696.         }
  697.     }
  698.     return OK;
  699. }
  700.  
  701. static int ext_ttx_dd (or, parm)
  702. OR_ptr or;
  703. struct type_Ext_TeletexDomainDefinedAttributes **parm;
  704. {
  705.     for (;or && or -> or_type == OR_DD; or = or -> or_next) {
  706.         if (or -> or_encoding != OR_ENC_TTX &&
  707.             or -> or_encoding != OR_ENC_TTX_AND_OR_PS)
  708.             continue;
  709.         *parm = (struct type_Ext_TeletexDomainDefinedAttributes *)
  710.             smalloc (sizeof **parm);
  711.         (*parm) -> next = NULL;
  712.         (*parm) -> TeletexDomainDefinedAttribute =
  713.             (struct type_Ext_TeletexDomainDefinedAttribute *)
  714.                 smalloc (sizeof (struct type_Ext_TeletexDomainDefinedAttribute));
  715.         (*parm) -> TeletexDomainDefinedAttribute -> type =
  716.             or_getttx (or -> or_ddname, or -> or_encoding);
  717.         (*parm) -> TeletexDomainDefinedAttribute -> value =
  718.             or_getttx (or -> or_value, or -> or_encoding);
  719.         parm = &(*parm) -> next;
  720.     }
  721.     return OK;
  722. }
  723.  
  724. static int ext_tt (or, parm)
  725. OR_ptr or;
  726. struct type_Ext_TerminalType **parm;
  727. {
  728.     (*parm) = (struct type_Ext_TerminalType *) smalloc (sizeof **parm);
  729.     (*parm) -> parm = atoi(or -> or_value);
  730.     return OK;
  731. }
  732.  
  733. static int ext_ena (or, parm)
  734. OR_ptr or;
  735. struct type_Ext_ExtendedNetworkAddress **parm;
  736. {
  737.     PE pe;
  738.     struct PSAPaddr *pa;
  739.  
  740.     *parm = (struct type_Ext_ExtendedNetworkAddress *)
  741.         smalloc (sizeof **parm);
  742.     bzero ((char *)*parm, sizeof **parm);
  743.  
  744.     while (or) {
  745.         switch (or -> or_type) {
  746.             case OR_ENA_N:
  747.             if ((*parm) -> offset == 0) {
  748.                 (*parm) -> offset = type_Ext_ExtendedNetworkAddress_e163__4__address;
  749.                 (*parm) -> un.e163__4__address =
  750.                     (struct element_Ext_2 *)
  751.                         smalloc (sizeof (struct element_Ext_2));
  752.             }
  753.             (*parm) -> un.e163__4__address ->
  754.                 number = STR2QB (or -> or_value);
  755.             break;
  756.             
  757.             case OR_ENA_S:
  758.             if ((*parm) -> offset == 0) {
  759.                 (*parm) -> offset = type_Ext_ExtendedNetworkAddress_e163__4__address;
  760.                 (*parm) -> un.e163__4__address =
  761.                     (struct element_Ext_2 *)
  762.                         smalloc (sizeof (struct element_Ext_2));
  763.             }
  764.             (*parm) -> un.e163__4__address ->
  765.                 sub__address = STR2QB(or -> or_value);
  766.             break;
  767.                 
  768.             case OR_ENA_P:
  769.             if ((*parm) -> offset != 0) {
  770.                 PP_LOG (LLOG_EXCEPTIONS,
  771.                     ("Both PSAP & e163 addr in OR"));
  772.                 return NOTOK;
  773.             }
  774.             if ((pa = str2paddr (or -> or_value)) == NULLPA)
  775.                 return NOTOK;
  776.             if (build_DSE_PSAPaddr (&pe, 1, 0, NULLCP, pa) == NOTOK)
  777.                 return NOTOK;
  778.             (*parm) -> offset = type_Ext_ExtendedNetworkAddress_psap__address;
  779.             (*parm) -> un.psap__address = pe;
  780.             break;
  781.             default:
  782.             break;
  783.         }
  784.         or = or -> or_next;
  785.     }
  786.     return OK;
  787. }
  788.  
  789. static int find_ext (ext, type)
  790. struct type_MTA_ExtensionAttributes **ext;
  791. int type;
  792. {
  793.     struct type_MTA_ExtensionAttributes *ep;
  794.  
  795.     for (ep = *ext; ep; ep = ep -> next) {
  796.         if (ep -> ExtensionAttribute -> type == type)
  797.             return 1;
  798.     }
  799.     return 0;
  800. }
  801.  
  802. static int build_ext_or (ext, or)
  803. struct type_MTA_ExtensionAttributes **ext;
  804. OR_ptr or;
  805. {
  806.     switch (or -> or_type) {
  807.         case OR_O:
  808.         return build_aext (or,
  809.                    &_ZExt_mod,
  810.                    _ZTeletexOrganizationNameExt,
  811.                    "TeletexOrganizationName",
  812.                    ext_ttx_str,
  813.                    AEXT_TTXORG,
  814.                    ext);
  815.                    
  816.         case OR_OU:
  817.         if (find_ext (ext, AEXT_TTXOU))
  818.             return OK;
  819.         return build_aext (or,
  820.                    &_ZExt_mod,
  821.                    _ZTeletexOrganizationalUnitNamesExt,
  822.                    "TeletexOrganizationalUnitNames",
  823.                    ext_ttxous,
  824.                    AEXT_TTXOU,
  825.                    ext);
  826.         case OR_S: /* first one */
  827.         case OR_G:
  828.         case OR_I:
  829.         case OR_GQ:
  830.         if (find_ext (ext, AEXT_TTXPN))
  831.             return OK;
  832.         return build_aext (or,
  833.                    &_ZExt_mod,
  834.                    _ZTeletexPersonalNameExt,
  835.                    "TeletexPersonalName",
  836.                    ext_ttx_pn,
  837.                    AEXT_TTXPN,
  838.                    ext);
  839.         case OR_DD:
  840.         if (find_ext (ext, AEXT_TTXDD))
  841.             return OK;
  842.         return build_aext (or,
  843.                    &_ZExt_mod,
  844.                    _ZTeletexDomainDefinedAttributesExt,
  845.                    "TeletexDomainDefinedAttributes",
  846.                    ext_ttx_dd,
  847.                    AEXT_TTXDD,
  848.                    ext);
  849.         case OR_CN:
  850.         return build_aext (or,
  851.                    &_ZExt_mod,
  852.                    _ZCommonNameExt,
  853.                    "CommonName",
  854.                    ext_ps_str,
  855.                    AEXT_CN,
  856.                    ext);
  857.         case OR_PDSNAME:
  858.         return build_aext (or,
  859.                    &_ZExt_mod,
  860.                    _ZPDSNameExt,
  861.                    "PDSName",
  862.                    ext_ps_str,
  863.                    AEXT_PDSNAME,
  864.                    ext);
  865.         case OR_PD_C:
  866.         return build_aext (or,
  867.                    &_ZExt_mod,
  868.                    _ZPhysicalDeliveryCountryNameExt,
  869.                    "PhysicalDeliveryCountryName",
  870.                    ext_psorns_str,
  871.                    AEXT_PDCN,
  872.                    ext);
  873.         case OR_POSTCODE:
  874.         return build_aext (or,
  875.                    &_ZExt_mod,
  876.                    _ZPostalCodeExt,
  877.                    "PostalCode",
  878.                    ext_psorns_str,
  879.                    AEXT_POSTCODE,
  880.                    ext);
  881.         case OR_PDO_NAME:
  882.         return build_aext (or,
  883.                    &_ZExt_mod,
  884.                    _ZPhysicalDeliveryOfficeNameExt,
  885.                    "PhysicalDeliveryOfficeName",
  886.                    ext_pdsparm,
  887.                    AEXT_PDONAME,
  888.                    ext);
  889.         case OR_PDO_NUM:
  890.         return build_aext (or,
  891.                    &_ZExt_mod,
  892.                    _ZPhysicalDeliveryOfficeNumberExt,
  893.                    "PhysicalDeliveryOfficeNumber",
  894.                    ext_pdsparm,
  895.                    AEXT_PDONUMB,
  896.                    ext);
  897.         case OR_OR_COMPS:
  898.         return build_aext (or,
  899.                    &_ZExt_mod,
  900.                    _ZExtensionORAddressComponentsExt,
  901.                    "ExtensionORAddressComponents",
  902.                    ext_pdsparm,
  903.                    AEXT_ORAC,
  904.                    ext);
  905.         case OR_PD_PN:
  906.         return build_aext (or,
  907.                    &_ZExt_mod,
  908.                    _ZPhysicalDeliveryPersonalNameExt,
  909.                    "PhysicalDeliveryPersonalName",
  910.                    ext_pdsparm,
  911.                    AEXT_PDPN,
  912.                    ext);
  913.         case OR_PD_O:
  914.         return build_aext (or,
  915.                    &_ZExt_mod,
  916.                    _ZPhysicalDeliveryOrganizationNameExt,
  917.                    "PhysicalDeliveryOrganizationName",
  918.                    ext_pdsparm,
  919.                    AEXT_PDORG,
  920.                    ext);
  921.         case OR_PD_COMPS:
  922.         return build_aext (or,
  923.                    &_ZExt_mod,
  924.                    _ZExtensionPhysicalDeliveryAddressComponentsExt,
  925.                    "ExtensionPhysicalDeliveryAddressComponents",
  926.                    ext_pdsparm,
  927.                    AEXT_EPDAC,
  928.                    ext);
  929.         case OR_UPA_PA:
  930.         if (find_ext (ext, AEXT_UNFPA))
  931.             return OK; /* already done it */
  932.         return build_aext (or,
  933.                    &_ZExt_mod,
  934.                    _ZUnformattedPostalAddressExt,
  935.                    "UnformattedPostalAddress",
  936.                    ext_upa,
  937.                    AEXT_UNFPA,
  938.                    ext);
  939.  
  940.         case OR_STREET:
  941.         return build_aext (or,
  942.                    &_ZExt_mod,
  943.                    _ZStreetAddressExt,
  944.                    "StreetAddress",
  945.                    ext_pdsparm,
  946.                    AEXT_STREET,
  947.                    ext);
  948.         case OR_PO_BOX:
  949.         return build_aext (or,
  950.                    &_ZExt_mod,
  951.                    _ZPostOfficeBoxAddressExt,
  952.                    "PostOfficeBoxAddress",
  953.                    ext_pdsparm,
  954.                    AEXT_POBOX,
  955.                    ext);
  956.         case OR_PRA:
  957.         return build_aext (or,
  958.                    &_ZExt_mod,
  959.                    _ZPosteRestanteAddressExt,
  960.                    "PosteRestanteAddress",
  961.                    ext_pdsparm,
  962.                    AEXT_POSTERES,
  963.                    ext);
  964.         case OR_UPN:
  965.         return build_aext (or,
  966.                    &_ZExt_mod,
  967.                    _ZUniquePostalNameExt,
  968.                    "UniquePostalName",
  969.                    ext_pdsparm,
  970.                    AEXT_UNIQPA,
  971.                    ext);
  972.         case OR_LPA:
  973.         return build_aext (or,
  974.                    &_ZExt_mod,
  975.                    _ZLocalPostalAttributesExt,
  976.                    "LocalPostalAttributes",
  977.                    ext_pdsparm,
  978.                    AEXT_LPA,
  979.                    ext);
  980.         case OR_ENA_N:
  981.         case OR_ENA_S:
  982.         case OR_ENA_P:
  983.         if (find_ext (ext, AEXT_NETADDR))
  984.             return OK;
  985.         return build_aext (or,
  986.                    &_ZExt_mod,
  987.                    _ZExtendedNetworkAddressExt,
  988.                    "ExtendedNetworkAddress",
  989.                    ext_ena,
  990.                    AEXT_NETADDR,
  991.                    ext);
  992.         case OR_TT:
  993.         return build_aext (or,
  994.                    &_ZExt_mod,
  995.                    _ZTerminalTypeExt,
  996.                    "TerminalType",
  997.                    ext_tt,
  998.                    AEXT_TT,
  999.                    ext);
  1000.     }
  1001.     return OK;
  1002. }
  1003.