home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Chans / lists / dl_x500.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  16.7 KB  |  756 lines
  1. /* dl_x500.c: */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Chans/lists/RCS/dl_x500.c,v 6.0 1991/12/18 20:10:43 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Chans/lists/RCS/dl_x500.c,v 6.0 1991/12/18 20:10:43 jpo Rel $
  9.  *
  10.  * $Log: dl_x500.c,v $
  11.  * Revision 6.0  1991/12/18  20:10:43  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16.  
  17.  
  18. #include "dlist.h"
  19. #include <isode/quipu/dua.h>
  20. #include <isode/quipu/read.h>
  21. #include <isode/quipu/modify.h>
  22. #include <isode/quipu/add.h>
  23. #include <isode/quipu/entry.h>
  24. #include <isode/quipu/ds_search.h>
  25. #include <isode/quipu/connection.h>    /* ds_search uses di_block - include this for lint !!! */
  26. #include <isode/quipu/bind.h>
  27.  
  28. extern AttributeType at_Member;
  29. extern AttributeType at_RoleOccupant;
  30. extern AttributeType at_CommonName;
  31. extern AttributeType at_Owner;
  32. extern AttributeType at_Permit;
  33. extern AttributeType at_Policy;
  34. extern AttributeType at_ORAddress;
  35. extern AttributeType at_RFC822;
  36. extern AttributeType at_GroupMember;
  37. extern AttributeType at_ObjectClass;
  38. extern OID role_oc;
  39. extern char * local_dit;
  40.  
  41. extern LLog * log_dsap;
  42.  
  43. extern Filter strfilter(), ocfilter(), joinfilter();
  44. extern Attr_Sequence as_combine();
  45. extern DN dn_append();
  46. extern char * dn2str();
  47.  
  48. static Attr_Sequence mailas = NULLATTR;
  49.  
  50. extern int str2dl ();
  51.  
  52. static int isPermanentError (error)
  53. struct DSError    *error;
  54. {
  55. /* DONE == temporary, NOTOK == permanent */
  56.  
  57.     switch (error -> dse_type) {
  58.         case DSE_REMOTEERROR:
  59.         case DSE_REFERRAL:
  60.         case DSE_ABANDONED:
  61.         return DONE;
  62.         case DSE_SERVICEERROR:
  63.         switch (error -> ERR_SERVICE.DSE_sv_problem) {
  64.             case DSE_SV_BUSY:
  65.             case DSE_SV_TIMELIMITEXCEEDED:
  66.             case DSE_SV_ADMINLIMITEXCEEDED:
  67.             return DONE;
  68.             default:
  69.             return NOTOK;
  70.         }
  71.         default:
  72.         return NOTOK;
  73.     }
  74. }
  75.  
  76. static int ds_cache_read (dn,as, pres) 
  77. DN dn;
  78. Attr_Sequence as;
  79. Attr_Sequence *pres;
  80. {
  81. struct ds_read_arg read_arg;
  82. struct ds_read_result result;
  83. struct DSError  error;
  84. static CommonArgs ca = default_common_args;
  85. Entry ptr;
  86.  
  87.     if ((ptr = local_find_entry (dn,TRUE)) != NULLENTRY) {
  88.         if (ptr->e_complete) {
  89.             *pres = ptr->e_attributes;
  90.             return OK;
  91.         }
  92.         if (as != NULLATTR) {
  93.             Attr_Sequence tmp;
  94.             for (tmp = as; tmp!= NULLATTR; tmp = tmp->attr_link) 
  95.                 if (as_find_type(ptr->e_attributes,tmp->attr_type) == NULLATTR) 
  96.                     goto do_read;
  97.             *pres = ptr->e_attributes;
  98.             return OK;
  99.         }
  100.     }
  101.  
  102. do_read:;
  103.  
  104.     read_arg.rda_common = ca; /* struct copy */
  105.  
  106.     read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
  107.     read_arg.rda_eis.eis_allattributes = FALSE;
  108.     read_arg.rda_eis.eis_select = as;
  109.     read_arg.rda_object = dn;
  110.     
  111.     if (ds_read (&read_arg, &error, &result) != DS_OK) {
  112.         int    resultint = isPermanentError(&error);
  113.         log_ds_error (&error);
  114.         ds_error_free (&error);
  115.         *pres = NULLATTR;
  116.         return resultint;
  117.     }
  118.  
  119.     result.rdr_entry.ent_attr = as_merge (result.rdr_entry.ent_attr,as_cpy(as));
  120.  
  121.     cache_entry (&result.rdr_entry,FALSE,TRUE);
  122.         *pres = result.rdr_entry.ent_attr;
  123.     return OK;
  124. }
  125.  
  126.  
  127. int dn2addr (dn, pres) 
  128. DN dn;
  129. Attr_Sequence    *pres;
  130. {
  131. Attr_Sequence found;
  132. int    result;
  133.  
  134.     if (mailas == NULLATTR) {
  135.         Attr_Sequence as;
  136.         mailas = as_comp_new (at_ORAddress,  NULLAV, NULLACL_INFO);
  137.         as = as_comp_new (at_RFC822,  NULLAV, NULLACL_INFO);
  138.         mailas = as_merge (mailas,as);
  139.         as = as_comp_new (at_ObjectClass,  NULLAV, NULLACL_INFO);
  140.         mailas = as_merge (mailas,as);
  141.         as = as_comp_new (at_RoleOccupant,  NULLAV, NULLACL_INFO);
  142.         mailas = as_merge (mailas,as);
  143.     }
  144.  
  145.     if ((result = ds_cache_read (dn,mailas, pres)) != OK)
  146.         return result;
  147.  
  148.     /* Have we got an address ? */
  149.     if ((found = as_find_type (*pres,at_ORAddress)) != NULLATTR) 
  150.         return OK;
  151.  
  152.     if ((found = as_find_type (*pres,at_RFC822)) != NULLATTR) 
  153.         return OK;
  154.  
  155.     /* NO address, is it a role ? */
  156.     if ((found = as_find_type (*pres,at_ObjectClass)) == NULLATTR) 
  157.         return NOTOK;
  158.  
  159.     if (check_in_oc(role_oc,found->attr_value)) {
  160.         /* Its a role :- follow member... */
  161.         if ((found = as_find_type (*pres,at_RoleOccupant)) == NULLATTR) 
  162.             return NOTOK;
  163.  
  164.         return dn2addr ((DN)&found->attr_value->avseq_av, pres);
  165.     }
  166.  
  167.     return OK;
  168.     
  169. }
  170.  
  171.  
  172. int dir_getdl_aux (dn, pres)
  173. DN dn;
  174. Attr_Sequence    *pres;
  175. {
  176. static Attr_Sequence astop = NULLATTR;
  177. int    result;
  178.  
  179.     if (astop == NULLATTR) {
  180.         Attr_Sequence as;
  181.         astop = as_comp_new (at_Member,  NULLAV, NULLACL_INFO);
  182.         as = as_comp_new (at_Owner,  NULLAV, NULLACL_INFO);
  183.         astop = as_merge (astop,as);
  184.         as = as_comp_new (at_Permit,  NULLAV, NULLACL_INFO);
  185.         astop = as_merge (astop,as);
  186.         as = as_comp_new (at_Policy,  NULLAV, NULLACL_INFO);
  187.         astop = as_merge (astop,as);
  188. /*
  189.         as = as_comp_new (acl_at,  NULLAV, NULLACL_INFO);
  190.         astop = as_merge (astop,as);
  191. */
  192.     }
  193.     result = ds_cache_read (dn,astop,pres);
  194.     return result;
  195. }
  196.  
  197. int dir_getdl (list, pas)
  198. char * list;
  199. Attr_Sequence *pas;
  200. {
  201.     DN dn;
  202.     int    result;
  203.     static  DN localdn = NULLDN;
  204.  
  205.     if ((localdn == NULLDN) && local_dit)
  206.         localdn = str2dn (local_dit);
  207.  
  208.     if ((result = str2dl(list,localdn,&dn)) != OK) 
  209.         return result;
  210.  
  211.     result = dir_getdl_aux (dn, pas);
  212.     dn_free (dn);
  213.  
  214.     return result;
  215. } 
  216.  
  217. int read_group_entry (dn, pres)
  218. DN dn;
  219. Attr_Sequence    *pres;
  220. {
  221. static Attr_Sequence astop = NULLATTR;
  222.  
  223.     if (astop == NULLATTR) 
  224.         astop = as_comp_new (at_GroupMember,  NULLAV, NULLACL_INFO);
  225.  
  226.     return (ds_cache_read (dn,astop, pres));
  227. }
  228.  
  229.  
  230. or_modify (ps,old,newname,at,dn) 
  231. PS ps;
  232. ORName * old;
  233. OR_ptr newname;
  234. AttributeType at;
  235. DN dn;
  236. {
  237. struct ds_modifyentry_arg mod_arg;
  238. struct DSError  error;
  239. static CommonArgs ca = default_common_args;
  240. struct entrymod *emnew;
  241. AttributeValue av;
  242. AV_Sequence avs;
  243. ORName * newor;
  244. ORName * orName_cpy();
  245. OR_ptr or_cpy();
  246.  
  247.     mod_arg.mea_common = ca;
  248.     mod_arg.mea_object = dn;
  249.  
  250.     emnew = em_alloc ();
  251.     emnew->em_type = EM_ADDVALUES;
  252.     av = AttrV_alloc();
  253.     av->av_syntax = str2syntax("ORName");
  254.     newor = orName_cpy (old);
  255.     if (newor->on_or != NULLOR)
  256.         or_free (newor->on_or);
  257.     newor->on_or = or_cpy(newname);
  258.     av->av_struct = (caddr_t) newor;
  259.     avs = avs_comp_new(av);
  260.     emnew->em_what = as_comp_new (AttrT_cpy(at),avs,NULLACL_INFO);
  261.  
  262.     mod_arg.mea_changes = emnew;
  263.  
  264.      emnew = em_alloc ();
  265.     emnew->em_type = EM_REMOVEVALUES;
  266.     av = AttrV_alloc();
  267.     av->av_syntax = str2syntax("ORName");
  268.     av->av_struct = (caddr_t) orName_cpy(old);
  269.     avs = avs_comp_new(av);
  270.     emnew->em_what = as_comp_new (AttrT_cpy(at),avs,NULLACL_INFO);
  271.     emnew->em_next = NULLMOD;
  272.  
  273.     mod_arg.mea_changes->em_next = emnew;
  274.  
  275.     if (ds_modifyentry (&mod_arg, &error) != DS_OK) {
  276.         ds_error (ps, &error);
  277.         return FALSE;
  278.     }
  279.     delete_cache (old->on_dn);
  280.  
  281.     ems_free (mod_arg.mea_changes);
  282.  
  283.     return TRUE;
  284. }
  285.  
  286. dl_modify (ps,name,dn,delete) 
  287. PS ps;
  288. ORName * name;
  289. DN dn;
  290. char delete;
  291. {
  292. struct ds_modifyentry_arg mod_arg;
  293. struct DSError  error;
  294. static CommonArgs ca = default_common_args;
  295. struct entrymod *emnew;
  296. AttributeValue av;
  297. AV_Sequence avs;
  298.  
  299.     mod_arg.mea_common = ca;
  300.     mod_arg.mea_object = dn;
  301.  
  302.     emnew = em_alloc ();
  303.     if (delete)
  304.         emnew->em_type = EM_REMOVEVALUES;
  305.     else
  306.         emnew->em_type = EM_ADDVALUES;
  307.     av = AttrV_alloc();
  308.     av->av_syntax = str2syntax("ORName");
  309.     av->av_struct = (caddr_t) name;
  310.     avs = avs_comp_new(av);
  311.     emnew->em_what = as_comp_new (AttrT_cpy(at_Member),avs,NULLACL_INFO);
  312.     emnew->em_next = NULLMOD;
  313.  
  314.     mod_arg.mea_changes = emnew;
  315.  
  316.     if (ds_modifyentry (&mod_arg, &error) != DS_OK) {
  317.         ds_error (ps, &error);
  318.         return FALSE;
  319.     }
  320.     delete_cache (dn);
  321.     ems_free (mod_arg.mea_changes);
  322.  
  323.     return TRUE;
  324. }
  325.  
  326. dl_modify_attr (ps,oldas,newas,dl,quiet) 
  327. PS ps;
  328. Attr_Sequence oldas,newas;
  329. DN dl;
  330. char quiet;
  331. {
  332. struct ds_modifyentry_arg mod_arg;
  333. struct DSError  error;
  334. static CommonArgs ca = default_common_args;
  335. struct entrymod *emnew;
  336.  
  337.     mod_arg.mea_common = ca;
  338.     mod_arg.mea_object = dl;
  339.  
  340.     if ((! oldas) || (oldas->attr_value == NULLAV)) {
  341.         emnew = em_alloc ();
  342.         emnew->em_type = EM_ADDATTRIBUTE;
  343.         emnew->em_what = as_comp_cpy (newas);
  344.            } else {
  345.         emnew = em_alloc ();
  346.         emnew->em_type = EM_REMOVEATTRIBUTE;
  347.         emnew->em_what = as_comp_cpy (oldas);
  348.         emnew->em_next = em_alloc();
  349.         emnew->em_next->em_type = EM_ADDATTRIBUTE;
  350.         emnew->em_next->em_what = as_comp_cpy (newas);
  351.            }
  352.  
  353.     emnew->em_next->em_next = NULLMOD;
  354.  
  355.     mod_arg.mea_changes = emnew;
  356.  
  357.     if (!quiet) {
  358.         ps_print (ps, "modifying...");
  359.         ps_flush (ps);
  360.     }
  361.  
  362.     if (ds_modifyentry (&mod_arg, &error) != DS_OK) {
  363.         ds_error (ps, &error);
  364.         return FALSE;
  365.     }
  366.  
  367.     if (!quiet) {
  368.         ps_print (ps, "OK\n");
  369.         ps_flush (ps);
  370.     }
  371.  
  372.     delete_cache (dl);
  373.     ems_free (mod_arg.mea_changes);
  374.  
  375.     return TRUE;
  376. }
  377.  
  378. dl_modify_owner (ps,olddn,newdn,dl,quiet) 
  379. PS ps;
  380. DN olddn,newdn;
  381. DN dl;
  382. char quiet;
  383. {
  384. struct ds_modifyentry_arg mod_arg;
  385. struct DSError  error;
  386. static CommonArgs ca = default_common_args;
  387. struct entrymod *emnew;
  388. AttributeValue av;
  389. AV_Sequence avs;
  390.  
  391.     mod_arg.mea_common = ca;
  392.     mod_arg.mea_object = dl;
  393.  
  394.     emnew = em_alloc ();
  395.     emnew->em_type = EM_REMOVEATTRIBUTE;
  396.     av = AttrV_alloc();
  397.     av->av_syntax = str2syntax("DN");
  398.     av->av_struct = (caddr_t) dn_cpy(olddn);
  399.     avs = avs_comp_new(av);
  400.     emnew->em_what = as_comp_new (AttrT_cpy(at_Owner),avs,NULLACL_INFO);
  401.  
  402.     emnew->em_next = em_alloc();
  403.     emnew->em_next->em_type = EM_ADDATTRIBUTE;
  404.     av = AttrV_alloc();
  405.     av->av_syntax = str2syntax("DN");
  406.     av->av_struct = (caddr_t) dn_cpy(newdn);
  407.     avs = avs_comp_new(av);
  408.     emnew->em_next->em_what = as_comp_new (AttrT_cpy(at_Owner),avs,NULLACL_INFO);
  409.     emnew->em_next->em_next = NULLMOD;
  410.  
  411.     mod_arg.mea_changes = emnew;
  412.  
  413.     if (!quiet) {
  414.         ps_print (ps, "modifying...");
  415.         ps_flush (ps);
  416.     }
  417.  
  418.     if (ds_modifyentry (&mod_arg, &error) != DS_OK) {
  419.         ds_error (ps, &error);
  420.         return FALSE;
  421.     }
  422.  
  423.     if (!quiet) {
  424.         ps_print (ps, "OK\n");
  425.         ps_flush (ps);
  426.     }
  427.  
  428.     delete_cache (dl);
  429.     ems_free (mod_arg.mea_changes);
  430.  
  431.     return TRUE;
  432. }
  433.  
  434. dl_bind (name,passwd)
  435. DN name;
  436. char * passwd;
  437. {
  438.   struct ds_bind_arg bindarg;
  439.   struct ds_bind_arg bindresult;
  440.   struct ds_bind_error binderr;
  441.  
  442.   bindarg.dba_version = DBA_VERSION_V1988;
  443.  
  444.   bindarg.dba_passwd_len = 0;
  445.   bindarg.dba_passwd [0] = '\0';
  446.  
  447.   if ((bindarg.dba_dn = name) != NULLDN) {
  448.     if (passwd) {
  449.         bindarg.dba_passwd_len = strlen (passwd);
  450.         (void) strcpy (bindarg.dba_passwd,passwd);
  451.         }
  452.   }
  453.  
  454.   if (ds_bind (&bindarg,&binderr,&bindresult) != DS_OK)
  455.         return NOTOK;
  456.   else
  457.     return OK;
  458. }
  459.  
  460.  
  461. dl_unbind ()
  462. {
  463.     (void) ds_unbind ();
  464. }
  465.  
  466.  
  467. str2dl (str,localdn,res)
  468. char * str;
  469. DN localdn;
  470. DN * res;
  471. {
  472. extern int print_parse_errors;
  473. int old;
  474. struct ds_search_arg search_arg;
  475. static struct ds_search_result result;
  476. struct DSError err;
  477. static CommonArgs ca = default_common_args;
  478. Filter filtcn, filtoc, filtand;
  479.  
  480.     old = print_parse_errors;
  481.     print_parse_errors = FALSE;
  482.     *res = str2dn (str);
  483.     print_parse_errors = old;
  484.  
  485.     if (*res != NULLDN)
  486.         return OK;
  487.  
  488.     filtcn = strfilter (at_CommonName,str,FILTERITEM_EQUALITY);
  489.     if ((filtoc = ocfilter ("ppDistributionList")) == NULLFILTER)
  490.         return NOTOK;
  491.  
  492.     filtoc->flt_next = filtcn;
  493.     filtand = joinfilter (filtoc,FILTER_AND);
  494.  
  495.     search_arg.sra_baseobject = localdn;
  496.     search_arg.sra_filter = filtand;
  497.     search_arg.sra_subset = SRA_ONELEVEL;
  498.     search_arg.sra_searchaliases = FALSE;
  499.     search_arg.sra_common = ca; /* struct copy */
  500.     search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
  501.     search_arg.sra_eis.eis_allattributes = FALSE;
  502.     search_arg.sra_eis.eis_select = NULLATTR;
  503.  
  504.     if (ds_search (&search_arg, &err, &result) != DS_OK) {
  505.         int    resultint = isPermanentError(&err);
  506.         filter_free (filtoc);
  507.         log_ds_error (&err);
  508.         ds_error_free (&err);
  509.         return resultint;
  510.     }
  511.     filter_free (filtoc);
  512.  
  513.     if (result.CSR_entries) {
  514.         if (*res = result.CSR_entries->ent_dn) /* assign */
  515.             return OK;
  516.     } 
  517.  
  518.     return NOTOK;
  519.     
  520. }
  521.  
  522.  
  523. DN search_postmaster (localdn)
  524. DN localdn;
  525. {
  526. struct ds_search_arg search_arg;
  527. static struct ds_search_result result;
  528. struct DSError err;
  529. static CommonArgs ca = default_common_args;
  530. Filter filtcn;
  531.  
  532.     if (mailas == NULLATTR) {
  533.         Attr_Sequence as;
  534.         mailas = as_comp_new (at_ORAddress,  NULLAV, NULLACL_INFO);
  535.         as = as_comp_new (at_RFC822,  NULLAV, NULLACL_INFO);
  536.         mailas = as_merge (mailas,as);
  537.         as = as_comp_new (at_ObjectClass,  NULLAV, NULLACL_INFO);
  538.         mailas = as_merge (mailas,as);
  539.         as = as_comp_new (at_RoleOccupant,  NULLAV, NULLACL_INFO);
  540.         mailas = as_merge (mailas,as);
  541.     }
  542.  
  543.     filtcn = strfilter (at_CommonName,"PostMaster",FILTERITEM_EQUALITY);
  544.  
  545.     search_arg.sra_baseobject = localdn;
  546.     search_arg.sra_filter = filtcn;
  547.     search_arg.sra_subset = SRA_ONELEVEL;
  548.     search_arg.sra_searchaliases = TRUE;
  549.     search_arg.sra_common = ca; /* struct copy */
  550.     search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
  551.     search_arg.sra_eis.eis_allattributes = FALSE;
  552.     search_arg.sra_eis.eis_select = mailas;
  553.  
  554.     if (ds_search (&search_arg, &err, &result) != DS_OK) {
  555.         filter_free (filtcn);
  556.         log_ds_error (&err);
  557.         ds_error_free (&err);
  558.         return NULLDN;
  559.     }
  560.     filter_free (filtcn);
  561.  
  562.     if (result.CSR_entries) {
  563.         cache_entry (result.CSR_entries,FALSE,TRUE);
  564.         return (result.CSR_entries->ent_dn);
  565.     } 
  566.  
  567.     return NULLDN;
  568. }
  569.     
  570. dl_showentry(ps,dn)
  571. PS ps;
  572. DN dn;
  573. {
  574. struct ds_read_arg read_arg;
  575. struct ds_read_result result;
  576. struct DSError  error;
  577. static CommonArgs ca = default_common_args;
  578. Entry ptr;
  579.  
  580.     if ((ptr = local_find_entry (dn,TRUE)) != NULLENTRY) 
  581.         if (ptr->e_complete) {
  582.             as_print (ps,ptr->e_attributes,READOUT);
  583.             return;
  584.         }
  585.  
  586.     read_arg.rda_common = ca; /* struct copy */
  587.  
  588.     read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
  589.     read_arg.rda_eis.eis_allattributes = TRUE;
  590.     read_arg.rda_eis.eis_select = NULLATTR;
  591.     read_arg.rda_object = dn;
  592.     
  593.     if (ds_read (&read_arg, &error, &result) != DS_OK) 
  594.         ds_error(ps,&error);
  595.  
  596.     cache_entry (&result.rdr_entry,FALSE,TRUE);
  597.  
  598.     as_print (ps,result.rdr_entry.ent_attr,READOUT);
  599. }
  600.  
  601. add_list_request (ps,where, listname, owner)
  602. PS ps;
  603. DN where;
  604. char * listname;
  605. DN owner;
  606. {
  607. struct ds_addentry_arg add_arg;
  608. struct DSError  error;
  609. Attr_Sequence as,nas;
  610. char buffer [LINESIZE];
  611. DN obj;
  612. DN dnc;
  613. static CommonArgs ca = default_common_args;
  614.  
  615.     add_arg.ada_common = ca; /* struct copy */
  616.  
  617.     (void) sprintf (buffer, "cn=%s-request",listname);
  618.     if ((as = str2as (buffer)) == NULLATTR)
  619.         return FALSE;
  620.     if ((dnc = str2dn (buffer)) == NULLDN)
  621.         return FALSE;
  622.  
  623.     (void) sprintf (buffer, "ObjectClass=ppRole&quipuobject");
  624.     if ((nas = str2as (buffer)) == NULLATTR)
  625.         return FALSE;
  626.     as = as_merge (as,nas);
  627.  
  628.     (void) sprintf (buffer, "roleOccupant=%s",dn2str(owner));
  629.     if ((nas = str2as (buffer)) == NULLATTR)
  630.         return FALSE;
  631.     as = as_merge (as,nas);
  632.  
  633.     (void) sprintf (buffer, "mhsORAddresses=%s-request",listname);
  634.     if ((nas = str2as (buffer)) == NULLATTR)
  635.         return FALSE;
  636.     as = as_merge (as,nas);
  637.  
  638.     (void) sprintf (buffer, 
  639.          "acl=others # read # entry & others # read # default & group #");
  640.     strcat (buffer, dn2str(owner));
  641.     strcat (buffer, "# write # entry & group #");
  642.     strcat (buffer, dn2str(owner));
  643.     strcat (buffer, "# write # default");
  644.     if ((nas = str2as (buffer)) == NULLATTR)
  645.         return FALSE;
  646.     as = as_merge (as,nas);
  647.  
  648.     obj = dn_cpy (where);
  649.     dn_append (obj,dn_cpy(dnc));
  650.     add_arg.ada_object = obj;
  651.     add_arg.ada_entry = as;
  652.  
  653.     if (ds_addentry (&add_arg, &error) != DS_OK) {
  654.         ds_error (ps,&error);
  655.         dn_free (obj);
  656.         as_free (as);
  657.         return FALSE;
  658.     }
  659.  
  660.     dn_free (obj);
  661.     as_free (as);
  662.  
  663.     return TRUE;
  664. }
  665.  
  666. add_new_list (ps, where,listname, owner, description,members)
  667. PS ps;
  668. DN where;
  669. char * listname;
  670. DN owner;
  671. char *description;
  672. Attr_Sequence members;
  673. {
  674. struct ds_addentry_arg add_arg;
  675. struct DSError  error;
  676. Attr_Sequence as,nas;
  677. char buffer [LINESIZE];
  678. DN obj;
  679. DN dnc;
  680. static CommonArgs ca = default_common_args;
  681.  
  682.     add_arg.ada_common = ca; /* struct copy */
  683.  
  684.     (void) sprintf (buffer, "cn=%s",listname);
  685.     if ((as = str2as (buffer)) == NULLATTR)
  686.         return FALSE;
  687.     if ((dnc = str2dn (buffer)) == NULLDN)
  688.         return FALSE;
  689.  
  690.     (void) sprintf (buffer, "ObjectClass=ppDistributionList&quipuobject");
  691.     if ((nas = str2as (buffer)) == NULLATTR)
  692.         return FALSE;
  693.     as = as_merge (as,nas);
  694.  
  695.     (void) sprintf (buffer, "owner=%s@cn=%s-request",dn2str(where),listname);
  696.     if ((nas = str2as (buffer)) == NULLATTR)
  697.         return FALSE;
  698.     as = as_merge (as,nas);
  699.  
  700.     if (members) 
  701.         as = as_merge (as,members);
  702.     else {
  703.         (void) sprintf (buffer, "mhsDLmembers=%s",dn2str(owner));
  704.         if ((nas = str2as (buffer)) == NULLATTR)
  705.             return FALSE;
  706.         as = as_merge (as,nas);
  707.         }
  708.  
  709.     if (description && *description != 0) {
  710.         (void) sprintf (buffer, "description=%s",description);
  711.         if ((nas = str2as (buffer)) == NULLATTR)
  712.             return FALSE;
  713.         as = as_merge (as,nas);
  714.     }
  715.  
  716.     (void) sprintf (buffer, "mhsDLSubmitPermissions=ALL");
  717.     if ((nas = str2as (buffer)) == NULLATTR)
  718.         return FALSE;
  719.     as = as_merge (as,nas);
  720.  
  721.     (void) sprintf (buffer, 
  722.          "acl=others # read # entry & others # read # default & group #");
  723.     strcat (buffer, dn2str(owner));
  724.     strcat (buffer, "# write # entry & group #");
  725.     strcat (buffer, dn2str(owner));
  726.     strcat (buffer, "# write # default");
  727.     if ((nas = str2as (buffer)) == NULLATTR)
  728.         return FALSE;
  729.     as = as_merge (as,nas);
  730.  
  731.     (void) sprintf (buffer, "mhsORAddresses=%s",listname);
  732.     if ((nas = str2as (buffer)) == NULLATTR)
  733.         return FALSE;
  734.     as = as_merge (as,nas);
  735.  
  736.     obj = dn_cpy (where);
  737.     dn_append (obj,dn_cpy(dnc));
  738.     add_arg.ada_object = obj;
  739.     add_arg.ada_entry = as;
  740.  
  741.     if (ds_addentry (&add_arg, &error) != DS_OK) {
  742.         ds_error (ps,&error);
  743.         dn_free (obj);
  744.         as_free (as);
  745.         return FALSE;
  746.     }
  747.  
  748.     dn_free (obj);
  749.     as_free (as);
  750.  
  751.     return TRUE;
  752. }
  753.  
  754.  
  755.  
  756.