home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 October / PCWorld_2000-10_cd1.bin / Komunik / sambar / _setup.1 / login.c < prev    next >
C/C++ Source or Header  |  2000-07-25  |  49KB  |  1,917 lines
  1. /*
  2. ** LOGIN
  3. **
  4. **      HTTP Wrapper for the Login/Logout/Profile Management Library
  5. **
  6. **        Confidential Property of Tod Sambar
  7. **        (c) Copyright Tod Sambar 1996-1997
  8. **        All rights reserved.
  9. **
  10. **
  11. ** Public Functions:
  12. **
  13. **        login_init
  14. **        user_login
  15. **        user_logout
  16. **        user_profile
  17. **        user_add
  18. **        user_delete
  19. **        user_update
  20. **        user_passwd
  21. **        user_list
  22. **        user_select
  23. **        user_maillist
  24. **        user_mailbox
  25. **        group_add
  26. **        group_delete
  27. **        group_list
  28. **        group_select
  29. **        ftp_connect
  30. **        mail_connect
  31. **        telnet_connect
  32. **
  33. **
  34. ** History:
  35. ** Chg#    Date    Description                                                Resp
  36. ** ----    -------    -------------------------------------------------------    ----
  37. **         27JAN96    Created                                                    sambar
  38. **         29MAR97    Added user list and update functions                    sambar
  39. **         30MAR97    Added FTP connection security                            sambar
  40. **         10OCT97    Added user password interface                            sambar
  41. **        14NOV97 Added group management                                    sambar
  42. **         28OCT98    Added MAIL connection security                            sambar
  43. */
  44.  
  45. #include    <stdio.h>
  46. #include    <stdlib.h>
  47. #include    <memory.h>
  48. #include    <string.h>
  49. #include    <login.h>
  50.  
  51. #ifndef    WIN32
  52. #include    <string.h>
  53. #endif    /* WIN32 */
  54.  
  55. /*
  56. ** Login RPC Commands
  57. */
  58. typedef struct login__rpcs
  59. {
  60.     SA_CHAR        *name;
  61.     SA_RPCPARAM    *params;
  62.     SA_INT        numparams;
  63.     SA_INT        auth;
  64.     SA_VOID        *func;
  65.     SA_CHAR        *descr;
  66. } LOGIN__RPCS;
  67.  
  68. static SA_RPCPARAM    adduserp [] =
  69. {
  70.     { "username",     1,    "User login." },
  71.     { "password",     0,    "User password." },
  72.     { "group",         0,    "User group." },
  73.     { "name",         0,    "User name." },
  74.     { "dir",         0,    "Ftp directory of the user." },
  75.     { "ftpprivs",     1,    "FTP priviledges of the user." },
  76.     { "ftpmax",     1,    "FTP maximum upload (MB)." },
  77.     { "mbox",         0,    "Create a mailbox for the user." }
  78. };
  79. static SA_RPCPARAM    upduserp [] =
  80. {
  81.     { "username",     1,    "User login." },
  82.     { "password",     0,    "User password." },
  83.     { "group",         0,    "User group." },
  84.     { "name",         0,    "User name." },
  85.     { "dir",         0,    "Ftp directory of the user." },
  86.     { "ftpprivs",     1,    "FTP priviledges of the user." },
  87.     { "ftpmax",     1,    "FTP maximum upload (MB)." },
  88.     { "mbox",         0,    "Create a mailbox for the user." }
  89. };
  90. static SA_RPCPARAM    deluserp [] =
  91. {
  92.     { "username",     1,    "User login." }
  93. };
  94. static SA_RPCPARAM    userpropp [] =
  95. {
  96.     { "username",     1,    "User login." },
  97.     { "prop",     1,    "User property: group,password,name,dir,ftpprivs,ftpmax" }
  98. };
  99. static SA_RPCPARAM    selectuserp [] =
  100. {
  101.     { "username",     0,    "User login." },
  102. };
  103. static SA_RPCPARAM    addgroupp [] =
  104. {
  105.     { "groupname",     1,    "Symbolic name of the group." }
  106. };
  107. static SA_RPCPARAM    delgroupp [] =
  108. {
  109.     { "groupname",     1,    "Symbolic name of the group." }
  110. };
  111. static SA_RPCPARAM    selectgroupp [] =
  112. {
  113.     { "username",     0,    "User to test against group list." }
  114. };
  115. static SA_RPCPARAM    userpasswdp [] =
  116. {
  117.     { "username",     1,    "User login." },
  118.     { "password",     0,    "Existing password for the user." },
  119.     { "newpasswd",     0,    "New password for the user." },
  120.     { "confpasswd",    0,    "Confirm new password." }
  121. };
  122. static SA_RPCPARAM    usermboxp [] =
  123. {
  124.     { "username",     1,    "User login." },
  125.     { "action",     1,    "Create/Delete user mailbox." }
  126. };
  127.  
  128. static LOGIN__RPCS        login_rpcs [] =
  129. {
  130.     { "adduser",     adduserp,    sizeof(adduserp)/sizeof(SA_RPCPARAM),
  131.        SA_AUTHORIZATION_ADMIN,    (SA_VOID *)user_add,
  132.       "Add a user to the system." },
  133.     { "upduser",     upduserp,    sizeof(upduserp)/sizeof(SA_RPCPARAM),    
  134.       SA_AUTHORIZATION_ADMIN,     (SA_VOID *)user_update,
  135.       "Update a user." }, 
  136.     { "deluser",    deluserp,    sizeof(deluserp)/sizeof(SA_RPCPARAM),     
  137.        SA_AUTHORIZATION_ADMIN,     (SA_VOID *)user_delete,
  138.       "Delete a user from the system." },
  139.     { "userprop",    userpropp,    sizeof(userpropp)/sizeof(SA_RPCPARAM),     
  140.       SA_AUTHORIZATION_ADMIN,     (SA_VOID *)user_prop,
  141.       "Get a single user attribute for display." },
  142.     { "listusers",    NULL, 0,
  143.       SA_AUTHORIZATION_ADMIN,     (SA_VOID *)user_list,
  144.       "List users for update/delete." },
  145.     { "selectuser",    selectuserp,sizeof(selectuserp)/sizeof(SA_RPCPARAM),    
  146.       SA_AUTHORIZATION_ADMIN,     (SA_VOID *)user_select,
  147.       "List users for selection in a pick list." },
  148.     { "mailusers",    NULL, 0,
  149.       SA_AUTHORIZATION_ADMIN,     (SA_VOID *)user_maillist,
  150.       "List mail users for update/delete." },
  151.     { "usermbox",    usermboxp,    sizeof(usermboxp)/sizeof(SA_RPCPARAM),    
  152.       SA_AUTHORIZATION_ADMIN,     (SA_VOID *)user_mailbox,
  153.       "Create/Delete a user mailbox." },
  154.  
  155.     { "addgroup",    addgroupp,    sizeof(addgroupp)/sizeof(SA_RPCPARAM),     
  156.       SA_AUTHORIZATION_ADMIN,    (SA_VOID *)group_add,
  157.       "Add a group to the system." },
  158.     { "delgroup",     delgroupp,    sizeof(delgroupp)/sizeof(SA_RPCPARAM),    
  159.       SA_AUTHORIZATION_ADMIN,     (SA_VOID *)group_delete,
  160.       "Delete a group from the system." },
  161.     { "listgroups",    NULL, 0,
  162.       SA_AUTHORIZATION_ADMIN,     (SA_VOID *)group_list,
  163.       "List groups for delete." },
  164.     { "selectgroup",selectgroupp,    sizeof(selectgroupp)/sizeof(SA_RPCPARAM),
  165.       SA_AUTHORIZATION_ADMIN,     (SA_VOID *)group_select,
  166.       "List groups for selection in a pick list." },
  167.  
  168.     { "userpasswd",    userpasswdp,    sizeof(userpasswdp)/sizeof(SA_RPCPARAM),    
  169.       SA_AUTHORIZATION_ALL,        (SA_VOID *)user_passwd,
  170.       "Interface to allow users to change their password." }
  171. };
  172.  
  173. /*
  174. **  LOGIN_INIT
  175. **
  176. **    Initialize the Login/Logout/Profile Interfaces for use by the 
  177. **    Sambar Server plugins.
  178. **
  179. **
  180. **  Parameters:
  181. **    sactx        Sambar Server context
  182. **
  183. **  Returns:
  184. **    SA_SUCCEED | SA_FAIL
  185. */
  186. SA_RETCODE SA_PUBLIC
  187. login_init(sactx)
  188. SA_CTX        *sactx;
  189. {
  190.     int        i;
  191.  
  192.     /* Register the User RPCs with the server                            */
  193.     for (i = 0; i < sizeof(login_rpcs) / sizeof(LOGIN__RPCS); i++)
  194.     {
  195.         if (sa_cmd_init(sactx, login_rpcs[i].name, login_rpcs[i].params, 
  196.             login_rpcs[i].numparams, login_rpcs[i].auth, login_rpcs[i].descr,
  197.             (SA_RPCFUNC)login_rpcs[i].func) != SA_SUCCEED)
  198.         {
  199.             sa_log(sactx, "Unable to initialize User Management RPCs");
  200.             return (SA_FAIL);
  201.         } 
  202.     }
  203.  
  204.     sa_log(sactx, "Login/Logout/Profile Management Initialized");
  205.  
  206.     return (SA_SUCCEED);
  207. }
  208.  
  209. /*
  210. **  USER_LOGIN
  211. **
  212. **    Login a user.  Verify the username/password against the Sambar Server
  213. **    password interfaces.  Store some profile information for use.
  214. **
  215. **  Parameters:
  216. **    sactx            Sambar Server Application context to release.
  217. **    saconn            Sambar Server User Connection handle.
  218. **    username        Name of the user logging in.
  219. **    usernamelen        Length of the user name
  220. **    password        Password of the user logging in.
  221. **    passwordlen        Length of the password.
  222. **    infop            Error return code
  223. **
  224. **  Return Values:
  225. **    SA_SUCCESS | SA_FAIL
  226. */
  227. SA_RETCODE SA_PUBLIC
  228. user_login(sactx, saconn, username, usernamelen, password, passwordlen, infop)
  229. SA_CTX        *sactx;
  230. SA_CONN        *saconn;
  231. SA_CHAR        *username;
  232. SA_INT        usernamelen;
  233. SA_CHAR        *password;
  234. SA_INT        passwordlen;
  235. SA_INT        *infop;
  236. {
  237.     SA_INT                namelen;
  238.     SA_BOOL                ntauth;
  239.     SA_BOOL                status;
  240.     SA_PASSWD            passwd;
  241.     LOGIN_PROFILE        *profile;
  242.     SA_CHAR                name[62];
  243.     SA_CHAR                buffer[512];
  244.  
  245.     ntauth = 0;
  246.     if (sa_ctx_props(sactx, SA_GET, SA_CTXPROP_NTAUTH, name, 30, 
  247.         (SA_INT *)NULL) == SA_SUCCEED)
  248.     {
  249.         if (stricmp(name, "true") == 0)
  250.             ntauth = 1;
  251.     }
  252.  
  253.     if (ntauth)
  254.     {
  255.         if ((sa_passwd_verify(sactx, username, usernamelen, password, 
  256.             passwordlen, &status) != SA_SUCCEED) ||
  257.             (!status))
  258.         {
  259.             (SA_VOID)sa_conn_props(saconn, SA_GET, SA_CONNPROP_HOST, name, 60,
  260.                 &namelen);
  261.             name[namelen] = '\0';
  262.             sprintf(buffer, 
  263.                 "Login for user '%s' failed - bad password (%s) [host %s]",
  264.                 username, password, name);
  265.             sa_log(sactx, buffer);
  266.             *infop = SA_E_INVALIDLOGIN;
  267.             return (SA_FAIL);
  268.         }
  269.     }
  270.     else
  271.     {
  272.         if (sa_passwd_lookup(sactx, username, usernamelen, &passwd) 
  273.             != SA_SUCCEED)
  274.         {
  275.             (SA_VOID)sa_conn_props(saconn, SA_GET, SA_CONNPROP_HOST, name, 60,
  276.                 &namelen);
  277.             name[namelen] = '\0';
  278.             sprintf(buffer, "Login for user '%s' failed [host %s]", 
  279.                 username, name);
  280.             sa_log(sactx, buffer);
  281.             *infop = SA_E_INVALIDLOGIN;
  282.             return (SA_FAIL);
  283.         }
  284.  
  285.         /* Verify the passwords are the same                            */
  286.         if ((passwd.passwordlen != passwordlen) ||
  287.             (strncmp(passwd.password, password, passwordlen) != 0))
  288.         {
  289.             (SA_VOID)sa_conn_props(saconn, SA_GET, SA_CONNPROP_HOST, name, 60,
  290.                 &namelen);
  291.             name[namelen] = '\0';
  292.             sprintf(buffer, 
  293.                 "Login for user '%s' failed - bad password (%s) [host %s]",
  294.                 username, password, name);
  295.             sa_log(sactx, buffer);
  296.             *infop = SA_E_INVALIDLOGIN;
  297.             return (SA_FAIL);
  298.         }
  299.     }
  300.  
  301.     /* Allocate and populate a user profile structure                    */
  302.     profile = (LOGIN_PROFILE *)malloc(sizeof(LOGIN_PROFILE));
  303.     if (profile == (LOGIN_PROFILE *)NULL)
  304.     {
  305.         sprintf(buffer, "Login for user '%s' failed - no memory", username);
  306.         sa_log(sactx, buffer);
  307.         *infop = SA_E_INVALIDLOGIN;
  308.         return (SA_FAIL);
  309.     }
  310.  
  311.     memset(profile, 0, sizeof(LOGIN_PROFILE));
  312.  
  313.     memcpy(profile->name, username, usernamelen);
  314.     profile->name[usernamelen] = '\0';
  315.     memcpy(profile->username, username, usernamelen);
  316.     profile->username[usernamelen] = '\0';
  317.  
  318.     if (!ntauth)
  319.     {
  320.         if (passwd.namelen > 0)
  321.         {
  322.             memcpy(profile->name, passwd.name, passwd.namelen);
  323.             profile->name[passwd.namelen] = '\0';
  324.         }
  325.  
  326.         if (passwd.grouplen > 0)
  327.         {
  328.             memcpy(profile->group, passwd.group, passwd.grouplen);
  329.             profile->group[passwd.grouplen] = '\0';
  330.         }
  331.     }
  332.  
  333.     /* Load the internal server profile for the user                    */
  334.     (SA_VOID)sa_profile_init(sactx, username, usernamelen, &profile->data);
  335.  
  336.     /* Save the user's profile handle with the user connection            */
  337.     if (sa_conn_key(saconn, SA_SET, LOGIN_PROFILE_KEY, (SA_VOID **)profile)
  338.         != SA_SUCCEED)
  339.     {
  340.         (SA_VOID)free(profile);
  341.         sa_log(sactx, "sa_conn_key(SET, LOGIN_PROFILE_KEY) failed!");
  342.         return (SA_FAIL);
  343.     }
  344.  
  345. #ifdef DEBUG
  346.     (SA_VOID)sa_conn_props(saconn, SA_GET, SA_CONNPROP_HOST, name, 60,
  347.         &namelen);
  348.     name[namelen] = '\0';
  349.     sprintf(buffer, "User '%s' logged in [host %s]", username, name);
  350.     sa_log(sactx, buffer);
  351. #endif    /* DEBUG */
  352.  
  353.     return (SA_SUCCEED);
  354. }
  355.  
  356. /*
  357. **  USER_LOGOUT
  358. **
  359. **    Log out a user.  Free profile resources.
  360. **
  361. **  Parameters:
  362. **    sactx        Sambar Server Application context to release.
  363. **    saconn        Sambar Server User Connection handle.
  364. **
  365. **  Return Values:
  366. **    SA_SUCCESS | SA_FAIL
  367. */
  368. SA_RETCODE SA_PUBLIC
  369. user_logout(sactx, saconn)
  370. SA_CTX        *sactx;
  371. SA_CONN        *saconn;
  372. {
  373.     LOGIN_PROFILE    *profile;
  374. #ifdef DEBUG
  375.     SA_CHAR            buffer[512];
  376. #endif    /* DEBUG */
  377.  
  378.     /* Get the user's handle from the profile context                    */
  379.     if (sa_conn_key(saconn, SA_GET, LOGIN_PROFILE_KEY, (SA_VOID **)&profile)
  380.         != SA_SUCCEED)
  381.     {
  382.         /* User never completed login                                    */
  383.         return (SA_SUCCEED);
  384.     }
  385.  
  386. #ifdef DEBUG
  387.     sprintf(buffer, "User '%s' logged out.", profile->username);
  388.     sa_log(sactx, buffer);
  389. #endif    /* DEBUG */
  390.  
  391.     if (profile->data != (SA_PROFILE *)NULL)
  392.     {
  393.         (SA_VOID)sa_profile_save(sactx, profile->data);
  394.         (SA_VOID)sa_profile_exit(sactx, profile->data);
  395.     }
  396.  
  397.     (void)free(profile);
  398.  
  399.     return (SA_SUCCEED);
  400. }
  401.  
  402. /*
  403. **  USER_PROFILE
  404. **
  405. **    Respond to a user profile request.
  406. **
  407. **  Parameters:
  408. **    sactx        Sambar Server Application context to release.
  409. **    saconn        Sambar Server User Connection handle.
  410. **    buffer        Profile attribute being queried.
  411. **    buflen        Length of the profile attribute.
  412. **    data        Buffer for the profile result 
  413. **                Note: A maximum of 512 bytes may be written to the data buffer.
  414. **
  415. **  Return Values:
  416. **    SA_SUCCESS | SA_FAIL
  417. */
  418. SA_RETCODE SA_PUBLIC
  419. user_profile(sactx, saconn, action, name, namelen, datap)
  420. SA_CTX        *sactx;
  421. SA_CONN        *saconn;
  422. SA_INT        action;
  423. SA_CHAR        *name;
  424. SA_INT        namelen;
  425. SA_VOID        *datap;
  426. {
  427.     LOGIN_PROFILE    *profile;
  428.     SA_CHAR            tmp[512];
  429.  
  430.     /* Get the user's profile handle                                     */
  431.     if (sa_conn_key(saconn, SA_GET, LOGIN_PROFILE_KEY, (SA_VOID **)&profile)
  432.         != SA_SUCCEED)
  433.     {
  434.         /* User never completed login                                    */
  435.         return (SA_FAIL);
  436.     }
  437.  
  438.     if (profile == (LOGIN_PROFILE *)NULL)
  439.     {
  440.         sa_log(sactx, "user_profile:  LOGIN_PROFILE_KEY returned NULL!");
  441.         return (SA_FAIL);
  442.     }
  443.  
  444.     if (profile->data == (SA_PROFILE *)NULL)
  445.     {
  446.         sprintf(tmp, "user_profile:  SA_PROFILE returned NULL for user %s!",
  447.             profile->name);
  448.         sa_log(sactx, tmp);
  449.         return (SA_FAIL);
  450.     }
  451.  
  452.     /* 
  453.     ** Profile lookup
  454.     */
  455.     if (action == SA_GET)
  456.     {
  457.         if ((namelen == 5) && (strncmp(name, "group", 5) == 0))
  458.         {
  459.             *((SA_CHAR **)datap) = profile->group;
  460.         }
  461.         else if ((namelen == 4) && (strncmp(name, "name", 4) == 0))
  462.         {
  463.             *((SA_CHAR **)datap) = profile->name;
  464.         }
  465.         else
  466.         {
  467.             if (sa_profile_get(sactx, profile->data, name, namelen, 
  468.                 (SA_CHAR **)datap) != SA_SUCCEED)
  469.             {
  470. #ifdef    DEBUG
  471.                 sprintf(tmp, "Profile attribute '%s' not found!", name);
  472.                 sa_log(sactx, tmp);
  473. #endif    /* DEBUG */
  474.                 return (SA_FAIL);
  475.             }
  476.         }
  477.     }
  478.     else
  479.     {
  480.         if (sa_profile_set(sactx, profile->data, name, namelen, 
  481.             (SA_CHAR *)datap) != SA_SUCCEED)
  482.         {
  483.             sprintf(tmp, "Profile attribute '%s' could not be set!", name);
  484.             sa_log(sactx, tmp);
  485.             return (SA_FAIL);
  486.         }
  487.     }
  488.  
  489.     return (SA_SUCCEED);
  490. }
  491.  
  492. /*
  493. **  USER_ADD
  494. **
  495. **    Add a new user
  496. **
  497. **  Parameters:
  498. **    sactx        Sambar Server context
  499. **    saconn        Sambar Server connection
  500. **    saparams    RPC Parameters
  501. **    infop        Error parameters
  502. **
  503. **  Returns:
  504. **    SA_SUCCEED | SA_FAIL
  505. */
  506. SA_RETCODE SA_PUBLIC
  507. user_add(sactx, saconn, saparams, infop)
  508. SA_CTX        *sactx;
  509. SA_CONN        *saconn;
  510. SA_PARAMS    *saparams;
  511. SA_INT        *infop;
  512. {
  513.     SA_INT        mbox;
  514.     SA_INT        datalen;
  515.     SA_CHAR        *data;
  516.     SA_PASSWD    passwd;
  517.  
  518.     memset(&passwd, 0, sizeof(SA_PASSWD));
  519.     
  520.     mbox = 0;
  521.     if (sa_param(sactx, saparams, "mbox", &data, &datalen) == SA_SUCCEED)
  522.     {
  523.         if ((datalen == 2) && (stricmp(data, "on") == 0))
  524.             mbox = 1;
  525.     }
  526.     
  527.     if (sa_param(sactx, saparams, "password", &data, &datalen) != SA_SUCCEED)
  528.     {
  529.         *infop = SA_E_INVALIDDATA;
  530.         sa_log(sactx, "user_add(): Expected parameter 'password'!");
  531.         return (SA_FAIL);
  532.     }
  533.     
  534.     passwd.passwordlen = MIN(datalen, SA_MAX_NAME);
  535.     if (passwd.passwordlen > 0)
  536.         memcpy(passwd.password, data, passwd.passwordlen);
  537.  
  538.     if (sa_param(sactx, saparams, "group", &data, &datalen) != SA_SUCCEED)
  539.     {
  540.         *infop = SA_E_INVALIDDATA;
  541.         sa_log(sactx, "user_add(): Expected parameter 'group'!");
  542.         return (SA_FAIL);
  543.     }
  544.     
  545.     passwd.grouplen = MIN(datalen, SA_MAX_NAME);
  546.     if (passwd.grouplen > 0)
  547.         memcpy(passwd.group, data, passwd.grouplen);
  548.  
  549.     if (sa_param(sactx, saparams, "name", &data, &datalen) != SA_SUCCEED)
  550.     {
  551.         *infop = SA_E_INVALIDDATA;
  552.         sa_log(sactx, "user_add(): Expected parameter 'name'!");
  553.         return (SA_FAIL);
  554.     }
  555.     
  556.     passwd.namelen = MIN(datalen, SA_MAX_NAME);
  557.     if (passwd.namelen > 0)
  558.         memcpy(passwd.name, data, passwd.namelen);
  559.  
  560.     if (sa_param(sactx, saparams, "dir", &data, &datalen) != SA_SUCCEED)
  561.     {
  562.         *infop = SA_E_INVALIDDATA;
  563.         sa_log(sactx, "user_add(): Expected parameter 'dir'!");
  564.         return (SA_FAIL);
  565.     }
  566.     
  567.     passwd.dirlen = MIN(datalen, SA_MAX_NAME);
  568.     if (passwd.dirlen > 0)
  569.         memcpy(passwd.dir, data, passwd.dirlen);
  570.  
  571.     if (sa_param(sactx, saparams, "ftpprivs", &data, &datalen) != SA_SUCCEED)
  572.     {
  573.         *infop = SA_E_INVALIDDATA;
  574.         sa_log(sactx, "user_add(): Expected parameter 'ftpprivs'!");
  575.         return (SA_FAIL);
  576.     }
  577.  
  578.     if (datalen < 12)
  579.         passwd.ftpprivs = atol(data);
  580.     
  581.     if (sa_param(sactx, saparams, "ftpmax", &data, &datalen) != SA_SUCCEED)
  582.     {
  583.         *infop = SA_E_INVALIDDATA;
  584.         sa_log(sactx, "user_add(): Expected parameter 'ftpmax'!");
  585.         return (SA_FAIL);
  586.     }
  587.     
  588.     if (datalen < 12)
  589.         passwd.ftpmax = atol(data);
  590.     if (passwd.ftpmax < 5)
  591.         passwd.ftpmax = 0;
  592.  
  593.     if (sa_param(sactx, saparams, "username", &data, &datalen) != SA_SUCCEED)
  594.     {
  595.         *infop = SA_E_INVALIDDATA;
  596.         sa_log(sactx, "user_add(): Expected parameter 'username'!");
  597.         return (SA_FAIL);
  598.     }
  599.  
  600.     if ((datalen == 0) || (datalen > SA_MAX_NAME))
  601.     {
  602.         *infop = SA_E_INVALIDDATA;
  603.         sa_log(sactx, "user_add(): 'username' field left NULL!");
  604.         return (SA_FAIL);
  605.     }
  606.  
  607.     /* Create the user account.                                            */
  608.     if (sa_passwd_add(sactx, data, datalen, &passwd) != SA_SUCCEED)
  609.     {
  610.         *infop = SA_E_ALREADYDEFINED;
  611.         sa_log(sactx, "user_add(): sa_passwd_add() failed!");
  612.         return (SA_FAIL);
  613.     }
  614.  
  615.     /* Create the user mailbox.                                            */
  616.     if (mbox)
  617.     {
  618.         if (sa_mbox_create(sactx, data) != SA_SUCCEED)
  619.         {
  620.             *infop = SA_E_ALREADYDEFINED;
  621.             sa_log(sactx, "user_add(): sa_mbox_create() failed!");
  622.             return (SA_FAIL);
  623.         }
  624.     }
  625.  
  626.     return (SA_SUCCEED);
  627. }
  628.  
  629. /*
  630. **  USER_UPDATE
  631. **
  632. **    Update an existing user
  633. **
  634. **  Parameters:
  635. **    sactx        Sambar Server context
  636. **    saconn        Sambar Server connection
  637. **    saparams    RPC Parameters
  638. **    infop        Error parameters
  639. **
  640. **  Returns:
  641. **    SA_SUCCEED | SA_FAIL
  642. */
  643. SA_RETCODE SA_PUBLIC
  644. user_update(sactx, saconn, saparams, infop)
  645. SA_CTX        *sactx;
  646. SA_CONN        *saconn;
  647. SA_PARAMS    *saparams;
  648. SA_INT        *infop;
  649. {
  650.     SA_INT        mbox;
  651.     SA_INT        datalen;
  652.     SA_CHAR        *data;
  653.     SA_PASSWD    passwd;
  654.  
  655.     memset(&passwd, 0, sizeof(SA_PASSWD));
  656.  
  657.     mbox = 0;
  658.     if (sa_param(sactx, saparams, "mbox", &data, &datalen) == SA_SUCCEED)
  659.     {
  660.         if ((datalen == 2) && (stricmp(data, "on") == 0))
  661.             mbox = 1;
  662.     }
  663.     
  664.     if (sa_param(sactx, saparams, "password", &data, &datalen) != SA_SUCCEED)
  665.     {
  666.         *infop = SA_E_INVALIDDATA;
  667.         sa_log(sactx, "user_update(): Expected parameter 'password'!");
  668.         return (SA_FAIL);
  669.     }
  670.     
  671.     passwd.passwordlen = MIN(datalen, SA_MAX_NAME);
  672.     if (passwd.passwordlen > 0)
  673.         memcpy(passwd.password, data, passwd.passwordlen);
  674.  
  675.     if (sa_param(sactx, saparams, "group", &data, &datalen) != SA_SUCCEED)
  676.     {
  677.         *infop = SA_E_INVALIDDATA;
  678.         sa_log(sactx, "user_update(): Expected parameter 'group'!");
  679.         return (SA_FAIL);
  680.     }
  681.     
  682.     passwd.grouplen = MIN(datalen, SA_MAX_NAME);
  683.     if (passwd.grouplen > 0)
  684.         memcpy(passwd.group, data, passwd.grouplen);
  685.  
  686.     if (sa_param(sactx, saparams, "name", &data, &datalen) != SA_SUCCEED)
  687.     {
  688.         *infop = SA_E_INVALIDDATA;
  689.         sa_log(sactx, "user_update(): Expected parameter 'name'!");
  690.         return (SA_FAIL);
  691.     }
  692.     
  693.     passwd.namelen = MIN(datalen, SA_MAX_NAME);
  694.     if (passwd.namelen > 0)
  695.         memcpy(passwd.name, data, passwd.namelen);
  696.  
  697.     if (sa_param(sactx, saparams, "dir", &data, &datalen) != SA_SUCCEED)
  698.     {
  699.         *infop = SA_E_INVALIDDATA;
  700.         sa_log(sactx, "user_update(): Expected parameter 'dir'!");
  701.         return (SA_FAIL);
  702.     }
  703.     
  704.     passwd.dirlen = MIN(datalen, SA_MAX_NAME);
  705.     if (passwd.dirlen > 0)
  706.         memcpy(passwd.dir, data, passwd.dirlen);
  707.  
  708.     if (sa_param(sactx, saparams, "ftpprivs", &data, &datalen) != SA_SUCCEED)
  709.     {
  710.         *infop = SA_E_INVALIDDATA;
  711.         sa_log(sactx, "user_update(): Expected parameter 'ftpprivs'!");
  712.         return (SA_FAIL);
  713.     }
  714.     
  715.     if (datalen < 12)
  716.         passwd.ftpprivs = atol(data);
  717.  
  718.     if (sa_param(sactx, saparams, "ftpmax", &data, &datalen) != SA_SUCCEED)
  719.     {
  720.         *infop = SA_E_INVALIDDATA;
  721.         sa_log(sactx, "user_update(): Expected parameter 'ftpmax'!");
  722.         return (SA_FAIL);
  723.     }
  724.     
  725.     if (datalen < 12)
  726.         passwd.ftpmax = atol(data);
  727.     if (passwd.ftpmax < 5)
  728.         passwd.ftpmax = 0;
  729.  
  730.     if (sa_param(sactx, saparams, "username", &data, &datalen) != SA_SUCCEED)
  731.     {
  732.         *infop = SA_E_INVALIDDATA;
  733.         sa_log(sactx, "user_update(): Expected parameter 'username'!");
  734.         return (SA_FAIL);
  735.     }
  736.  
  737.     if ((datalen == 0) || (datalen > SA_MAX_NAME))
  738.     {
  739.         *infop = SA_E_INVALIDDATA;
  740.         sa_log(sactx, "user_update(): 'username' field left NULL!");
  741.         return (SA_FAIL);
  742.     }
  743.  
  744.     if (sa_passwd_update(sactx, data, datalen, &passwd) != SA_SUCCEED)
  745.     {
  746.         *infop = SA_E_ALREADYDEFINED;
  747.         sa_log(sactx, "user_update(): sa_passwd_update() failed!");
  748.         return (SA_FAIL);
  749.     }
  750.  
  751.     /* Create the user mailbox.                                            */
  752.     if (mbox)
  753.     {
  754.         if (sa_mbox_create(sactx, data) != SA_SUCCEED)
  755.         {
  756.             *infop = SA_E_ALREADYDEFINED;
  757.             sa_log(sactx, "user_update(): sa_mbox_create() failed!");
  758.             return (SA_FAIL);
  759.         }
  760.     }
  761.  
  762.     return (SA_SUCCEED);
  763. }
  764.  
  765. /*
  766. **  USER_DELETE
  767. **
  768. **    Delete an existing user
  769. **
  770. **  Parameters:
  771. **    sactx        Sambar Server context
  772. **    saconn        Sambar Server connection
  773. **    saparams    RPC Parameters
  774. **    infop        Error parameters
  775. **
  776. **  Returns:
  777. **    SA_SUCCEED | SA_FAIL
  778. */
  779. SA_RETCODE SA_PUBLIC
  780. user_delete(sactx, saconn, saparams, infop)
  781. SA_CTX        *sactx;
  782. SA_CONN        *saconn;
  783. SA_PARAMS    *saparams;
  784. SA_INT        *infop;
  785. {
  786.     SA_INT        datalen;
  787.     SA_INT        sysadminlen;
  788.     SA_CHAR        *data;
  789.     SA_CHAR        sysadmin[SA_MAX_NAME + 1];
  790.  
  791.     /* Get the sysadmin user (disallow deletes)                            */
  792.     if (sa_ctx_props(sactx, SA_GET, SA_CTXPROP_SYSADMIN, (SA_BYTE *)sysadmin,
  793.         SA_MAX_NAME, &sysadminlen) != SA_SUCCEED)
  794.     {
  795.         sa_log(sactx, "user_delete(): failure retrieving system admin user!");
  796.         return (SA_FAIL);
  797.     }
  798.  
  799.     if (sa_param(sactx, saparams, "username", &data, &datalen) != SA_SUCCEED)
  800.     {
  801.         *infop = SA_E_INVALIDDATA;
  802.         sa_log(sactx, "user_delete(): Expected parameter 'username'!");
  803.         return (SA_FAIL);
  804.     }
  805.  
  806.     if ((datalen == 0) || (datalen > SA_MAX_NAME))
  807.     {
  808.         *infop = SA_E_INVALIDDATA;
  809.         sa_log(sactx, "user_delete(): 'username' field left NULL!");
  810.         return (SA_FAIL);
  811.     }
  812.  
  813.     /* Don't allow the deletion of the system administrator                */
  814.     if ((datalen != sysadminlen) || (memcmp(sysadmin, data, sysadminlen) != 0))
  815.     {
  816.         (SA_VOID)sa_passwd_delete(sactx, data, datalen);
  817.         (SA_VOID)sa_mbox_delete(sactx, data);
  818.     }
  819.  
  820.     return (SA_SUCCEED);
  821. }
  822.  
  823. /*
  824. **  USER_SELECT
  825. **
  826. **    List all users for selection.
  827. **
  828. **  Parameters:
  829. **    sactx        Sambar Server context
  830. **    saconn        Sambar Server connection
  831. **    saparams    RPC Parameters
  832. **    infop        Error parameters
  833. **
  834. **  Returns:
  835. **    SA_SUCCEED | SA_FAIL
  836. **
  837. **  Notes:
  838. **    This list is truncated at 500 names.
  839. */
  840. SA_RETCODE SA_PUBLIC
  841. user_select(sactx, saconn, saparams, infop)
  842. SA_CTX        *sactx;
  843. SA_CONN        *saconn;
  844. SA_PARAMS    *saparams;
  845. SA_INT        *infop;
  846. {
  847.     SA_INT            i;
  848.     SA_BOOL            selected;
  849.     SA_INT            usernamelen;
  850.     SA_INT            numusers;
  851.     SA_CHAR            *username;
  852.     SA_USER            users[500];
  853.     SA_CHAR            buffer[512];
  854.  
  855.     /* If a username is provided make it SELECTED in the OPTION list    */
  856.     (SA_VOID)sa_param(sactx, saparams, "username", &username, &usernamelen);
  857.  
  858.     if (sa_passwd_list(sactx, users, 500, &numusers) != SA_SUCCEED)
  859.     {
  860.         sa_log(sactx, "user_select(): failure retrieving names list!");
  861.         return (SA_FAIL);
  862.     }
  863.  
  864.     /* We could sort the names alphabetically at this point...            */
  865.  
  866.     /* Display the list of users.                                        */
  867.     for (i = 0; i < numusers; i++)
  868.     {
  869.         selected = 0;
  870.         if ((users[i].usernamelen == usernamelen) &&
  871.             (memcmp(username, users[i].username, usernamelen) == 0))
  872.         {
  873.             selected = 1;
  874.         }
  875.  
  876.         sprintf(buffer, "<OPTION %s>%s\n", (selected ? "SELECTED" : ""),
  877.                 users[i].username);
  878.  
  879.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  880.             return (SA_FAIL);
  881.     }
  882.  
  883.     return (SA_SUCCEED);
  884. }
  885.  
  886. /*
  887. **  USER_LIST
  888. **
  889. **    List all users for delete or update.
  890. **
  891. **  Parameters:
  892. **    sactx        Sambar Server context
  893. **    saconn        Sambar Server connection
  894. **    saparams    RPC Parameters
  895. **    infop        Error parameters
  896. **
  897. **  Returns:
  898. **    SA_SUCCEED | SA_FAIL
  899. **
  900. **  Notes:
  901. **    This list is truncated at 500 names.
  902. **    List users by group...
  903. */
  904. SA_RETCODE SA_PUBLIC
  905. user_list(sactx, saconn, saparams, infop)
  906. SA_CTX        *sactx;
  907. SA_CONN        *saconn;
  908. SA_PARAMS    *saparams;
  909. SA_INT        *infop;
  910. {
  911.     SA_INT            i;
  912.     SA_INT            j;
  913.     SA_INT            sysadminlen;
  914.     SA_INT            numusers;
  915.     SA_INT            numgroups;
  916.     SA_GROUP        groups[100];
  917.     SA_USER            users[500];
  918.     SA_CHAR            sysadmin[SA_MAX_NAME + 1];
  919.     SA_CHAR            buffer[512];
  920.  
  921.     /* Get the sysadmin user (disallow deletes)                            */
  922.     if (sa_ctx_props(sactx, SA_GET, SA_CTXPROP_SYSADMIN, (SA_BYTE *)sysadmin,
  923.         SA_MAX_NAME, &sysadminlen) != SA_SUCCEED)
  924.     {
  925.         sa_log(sactx, "user_list(): failure retrieving system admin user!");
  926.         return (SA_FAIL);
  927.     }
  928.  
  929.     if (sa_passwd_list(sactx, users, 500, &numusers) != SA_SUCCEED)
  930.     {
  931.         sa_log(sactx, "user_list(): failure retrieving names list!");
  932.         return (SA_FAIL);
  933.     }
  934.  
  935.     if (sa_group_list(sactx, groups, 100, &numgroups) != SA_SUCCEED)
  936.     {
  937.         sa_log(sactx, "user_list(): failure retrieving groups list!");
  938.         return (SA_FAIL);
  939.     }
  940.  
  941.     /* We could sort the list alphabetically at this point.                */
  942.  
  943.     /*
  944.     ** Display the users by "group".
  945.     ** Zero the usernamelen after displaying so we can put the rest in
  946.     ** the "other" list.
  947.     */
  948.     for (j = 0; j < numgroups; j++)
  949.     {
  950.         sprintf(buffer, "<FONT SIZE=+1 COLOR=#990033>%s</FONT><BLOCKQUOTE>\n",
  951.             groups[j].name);
  952.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  953.             return (SA_FAIL);
  954.         
  955.         /* Display the users in that group.                                */
  956.         for (i = 0; i < numusers; i++)
  957.         {
  958.             if ((users[i].usernamelen > 0) && 
  959.                 (users[i].grouplen == groups[j].namelen) &&
  960.                 (memcmp(users[i].group, groups[j].name, users[i].grouplen)==0))
  961.             {
  962.                 /* Make sure we don't display the user twice.            */
  963.                 users[i].usernamelen = 0;
  964.  
  965.                 if ((users[i].usernamelen != sysadminlen) ||
  966.                     (strncmp(sysadmin, users[i].username, sysadminlen) != 0))
  967.                 {
  968.                     sprintf(buffer, 
  969.                         "<A HREF=\"/session/deluser?username=%s&RCpage=/sysadmin/usermgmt/userlist.stm\" onClick=\"return confirmDelete()\"><IMG border=0 HEIGHT=20 WIDTH=20 SRC=\"/sysimage/system/trash.gif\"></A>\n",
  970.                         users[i].username);
  971.  
  972.                     if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  973.                         return (SA_FAIL);
  974.                 }
  975.  
  976.                 sprintf(buffer, 
  977.                     "<A HREF=\"/sysadmin/usermgmt/upduser.stm?RCSusername=%s\" TARGET=body><IMG border=0 HEIGHT=20 WIDTH=20 SRC=\"/sysimage/system/info.gif\"> %s</A><BR>\n",
  978.                     users[i].username, users[i].username);
  979.  
  980.                 if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  981.                     return (SA_FAIL);
  982.             }
  983.         }
  984.  
  985.         if (sa_conn_send(saconn, "</BLOCKQUOTE>", SA_NULLTERM) != SA_SUCCEED)
  986.             return (SA_FAIL);
  987.     }
  988.  
  989.     /* Display the "other" group                                        */
  990.     sprintf(buffer, "<FONT SIZE=+1 COLOR=#990066>%s</FONT><BLOCKQUOTE>\n", 
  991.         SA_DEFAULT_GROUP);
  992.     if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  993.         return (SA_FAIL);
  994.         
  995.     /* Display the users in that group.                                    */
  996.     for (i = 0; i < numusers; i++)
  997.     {
  998.         /* Display all users not in any other group.                    */
  999.         if (users[i].usernamelen > 0)
  1000.         {
  1001.             if ((users[i].usernamelen != sysadminlen) ||
  1002.                 (strncmp(sysadmin, users[i].username, sysadminlen) != 0))
  1003.             {
  1004.                 sprintf(buffer, 
  1005.                     "<A HREF=\"/session/deluser?username=%s&RCpage=/sysadmin/usermgmt/userlist.stm\" onClick=\"return confirmDelete()\"><IMG border=0 HEIGHT=15 WIDTH=15 SRC=\"/sysimage/system/trash.gif\"></A>\n",
  1006.                     users[i].username);
  1007.  
  1008.                 if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1009.                     return (SA_FAIL);
  1010.             }
  1011.  
  1012.             sprintf(buffer, 
  1013.                 "<A HREF=\"/sysadmin/usermgmt/upduser.stm?RCSusername=%s\" TARGET=body><IMG border=0 HEIGHT=15 WIDTH=15 SRC=\"/sysimage/system/info.gif\"> %s</A><BR>\n",
  1014.                 users[i].username, users[i].username);
  1015.  
  1016.             if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1017.                 return (SA_FAIL);
  1018.         }
  1019.  
  1020.     }
  1021.  
  1022.     if (sa_conn_send(saconn, "</BLOCKQUOTE>\n", SA_NULLTERM) != SA_SUCCEED)
  1023.         return (SA_FAIL);
  1024.  
  1025.     return (SA_SUCCEED);
  1026. }
  1027.  
  1028. /*
  1029. **  USER_PASSWD
  1030. **
  1031. **    Update a user' password.
  1032. **
  1033. **  Parameters:
  1034. **    sactx        Sambar Server context
  1035. **    saconn        Sambar Server connection
  1036. **    saparams    RPC Parameters
  1037. **    infop        Error parameters
  1038. **
  1039. **  Returns:
  1040. **    SA_SUCCEED | SA_FAIL
  1041. */
  1042. SA_RETCODE SA_PUBLIC
  1043. user_passwd(sactx, saconn, saparams, infop)
  1044. SA_CTX        *sactx;
  1045. SA_CONN        *saconn;
  1046. SA_PARAMS    *saparams;
  1047. SA_INT        *infop;
  1048. {
  1049.     SA_INT        datalen;
  1050.     SA_INT        passwordlen;
  1051.     SA_INT        usernamelen;
  1052.     SA_CHAR        *data;
  1053.     SA_CHAR        *password;
  1054.     SA_CHAR        *username;
  1055.     SA_PASSWD    passwd;
  1056.  
  1057.     /* What username is being updated?                                    */
  1058.     if (sa_param(sactx, saparams, "username", &username, &usernamelen) 
  1059.         != SA_SUCCEED)
  1060.     {
  1061.         *infop = SA_E_INVALIDDATA;
  1062.         sa_log(sactx, "user_passwd(): Expected parameter 'username'!");
  1063.         return (SA_FAIL);
  1064.     }
  1065.  
  1066.     if ((usernamelen == 0) || (usernamelen > SA_MAX_NAME))
  1067.     {
  1068.         *infop = SA_E_INVALIDDATA;
  1069.         sa_log(sactx, "user_update(): 'username' field left NULL!");
  1070.         return (SA_FAIL);
  1071.     }
  1072.  
  1073.     /* Lookup the username provided for update.                            */
  1074.     if (sa_passwd_lookup(sactx, username, usernamelen, &passwd) != SA_SUCCEED)
  1075.     {
  1076.         *infop = SA_E_INVALIDDATA;
  1077.         sa_log(sactx, "user_passwd(): sa_passwd_lookup() failed!");
  1078.         return (SA_FAIL);
  1079.     }
  1080.  
  1081.     /* Make sure that the password is valid.                        */
  1082.     if (sa_param(sactx, saparams, "password", &data, &datalen) != SA_SUCCEED)
  1083.     {
  1084.         *infop = SA_E_INVALIDDATA;
  1085.         sa_log(sactx, "user_passwd(): Expected parameter 'password'!");
  1086.         return (SA_FAIL);
  1087.     }
  1088.     
  1089.     /* Compare with the existing password.                            */
  1090.     if (datalen != passwd.passwordlen)
  1091.     {    
  1092.         *infop = SA_E_INVALIDDATA;
  1093.         sa_log(sactx, "user_passwd(): Invalid password provided.");
  1094.         return (SA_FAIL);
  1095.     }
  1096.     
  1097.     if (datalen > 0)
  1098.     {
  1099.         if (memcmp(passwd.password, data, datalen) != 0)
  1100.         {
  1101.             *infop = SA_E_INVALIDDATA;
  1102.             sa_log(sactx, "user_passwd(): Invalid password provided.");
  1103.             return (SA_FAIL);
  1104.         }
  1105.     }
  1106.  
  1107.     /* Get the new password.                                            */
  1108.     if (sa_param(sactx, saparams, "newpasswd", &password, &passwordlen) 
  1109.         != SA_SUCCEED)
  1110.     {
  1111.         *infop = SA_E_INVALIDDATA;
  1112.         sa_log(sactx, "user_passwd(): Expected parameter 'newpasswd'!");
  1113.         return (SA_FAIL);
  1114.     }
  1115.     
  1116.     /* Confirm the new password.                                        */
  1117.     if (sa_param(sactx, saparams, "confpasswd", &data, &datalen) 
  1118.         != SA_SUCCEED)
  1119.     {
  1120.         *infop = SA_E_INVALIDDATA;
  1121.         sa_log(sactx, "user_passwd(): Expected parameter 'confpasswd'!");
  1122.         return (SA_FAIL);
  1123.     }
  1124.  
  1125.     /* Does the new password and confirm password match?                */
  1126.     if ((passwordlen > 0) && (datalen > 0))
  1127.     {
  1128.         if ((passwordlen != datalen) ||
  1129.             (memcmp(password, data, datalen) != 0))
  1130.         {
  1131.             *infop = SA_E_INVALIDDATA;
  1132.             sa_log(sactx, 
  1133.                 "user_passwd(): New & confirmation password do not match!");
  1134.             return (SA_FAIL);
  1135.         }
  1136.     }
  1137.     
  1138.     passwd.passwordlen = MIN(datalen, SA_MAX_NAME);
  1139.     if (passwd.passwordlen > 0)
  1140.         memcpy(passwd.password, data, passwd.passwordlen);
  1141.  
  1142.     if (sa_passwd_update(sactx, username, usernamelen, &passwd) != SA_SUCCEED)
  1143.     {
  1144.         sa_log(sactx, "user_passwd(): sa_passwd_update() failed!");
  1145.         return (SA_FAIL);
  1146.     }
  1147.  
  1148.     return (SA_SUCCEED);
  1149. }
  1150.  
  1151. /*
  1152. **  USER_PROP
  1153. **
  1154. **    Lookup and return a single user property.
  1155. **
  1156. **  Parameters:
  1157. **    sactx        Sambar Server context
  1158. **    saconn        Sambar Server connection
  1159. **    saparams    RPC Parameters
  1160. **    infop        Error parameters
  1161. **
  1162. **  Return Values:
  1163. **    SA_SUCCESS | SA_FAIL
  1164. */
  1165. SA_RETCODE SA_PUBLIC
  1166. user_prop(sactx, saconn, saparams, infop)
  1167. SA_CTX        *sactx;
  1168. SA_CONN        *saconn;
  1169. SA_PARAMS    *saparams;
  1170. SA_INT        *infop;
  1171. {
  1172.     SA_PASSWD            passwd;
  1173.     SA_INT                userlen;
  1174.     SA_CHAR                *user;
  1175.     SA_INT                proplen;
  1176.     SA_CHAR                *prop;
  1177.     SA_CHAR                buffer[512];
  1178.  
  1179.     /* Get the page to direct to for user update                        */
  1180.     if (sa_param(sactx, saparams, "username", &user, &userlen) != SA_SUCCEED)
  1181.     {
  1182.         *infop = SA_E_INVALIDDATA;
  1183.         sa_log(sactx, "user_prop(): Expected parameter 'username'!");
  1184.         return (SA_FAIL);
  1185.     }
  1186.  
  1187.     if ((userlen == 0) || (userlen > SA_MAX_NAME))
  1188.     {
  1189.         *infop = SA_E_INVALIDDATA;
  1190.         sa_log(sactx, "user_prop(): 'username' field left NULL!");
  1191.         return (SA_FAIL);
  1192.     }
  1193.  
  1194.     /* Get the property being looked up.                                */
  1195.     if (sa_param(sactx, saparams, "prop", &prop, &proplen) != SA_SUCCEED)
  1196.     {
  1197.         *infop = SA_E_INVALIDDATA;
  1198.         sa_log(sactx, "user_prop(): Expected parameter 'prop'!");
  1199.         return (SA_FAIL);
  1200.     }
  1201.  
  1202.     if ((proplen == 0) || (proplen > SA_MAX_NAME))
  1203.     {
  1204.         *infop = SA_E_INVALIDDATA;
  1205.         sa_log(sactx, "user_prop(): 'prop' field left NULL!");
  1206.         return (SA_FAIL);
  1207.     }
  1208.  
  1209.     if (sa_passwd_lookup(sactx, user, userlen, &passwd) != SA_SUCCEED)
  1210.     {
  1211.         sprintf(buffer, "User lookup for '%s' failed.", user);
  1212.         sa_log(sactx, buffer);
  1213.         *infop = SA_E_INVALIDDATA;
  1214.         return (SA_FAIL);
  1215.     }
  1216.  
  1217.     /* Lookup and return the appropriate property                        */
  1218.     if (strcmp(prop, "group") == 0)
  1219.     {
  1220.         if (sa_conn_send(saconn, passwd.group, passwd.grouplen) != SA_SUCCEED)
  1221.             return (SA_FAIL);
  1222.     }
  1223.     else if (strcmp(prop, "password") == 0)
  1224.     {
  1225.         if (sa_conn_send(saconn, passwd.password, passwd.passwordlen) 
  1226.             != SA_SUCCEED)
  1227.         {
  1228.             return (SA_FAIL);
  1229.         }
  1230.     }
  1231.     else if (strcmp(prop, "name") == 0)
  1232.     {
  1233.         if (sa_conn_send(saconn, passwd.name, passwd.namelen) != SA_SUCCEED)
  1234.             return (SA_FAIL);
  1235.     }
  1236.     else if (strcmp(prop, "dir") == 0)
  1237.     {
  1238.         if (sa_conn_send(saconn, passwd.dir, passwd.dirlen) != SA_SUCCEED)
  1239.             return (SA_FAIL);
  1240.     }
  1241.     else if (strcmp(prop, "ftpprivs") == 0)
  1242.     {
  1243.         if (sa_param(sactx, saparams, "checked", &prop, &proplen) == SA_SUCCEED)
  1244.         {
  1245.             int        tmp;
  1246.  
  1247.             tmp = 0;
  1248.             if (proplen > 0)
  1249.                 tmp = atoi(prop);
  1250.         
  1251.             if (tmp == passwd.ftpprivs)
  1252.             {
  1253.                 if (sa_conn_send(saconn, "CHECKED", SA_NULLTERM) != SA_SUCCEED)
  1254.                     return (SA_FAIL);
  1255.             }
  1256.         }
  1257.         else
  1258.         {
  1259.             sprintf(buffer, "%ld", passwd.ftpprivs);
  1260.             if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1261.                 return (SA_FAIL);
  1262.         }
  1263.     }
  1264.     else if (strcmp(prop, "ftpmax") == 0)
  1265.     {
  1266.         if (passwd.ftpmax < 5)
  1267.             passwd.ftpmax = 0;
  1268.         sprintf(buffer, "%ld", passwd.ftpmax);
  1269.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1270.             return (SA_FAIL);
  1271.     }
  1272.     else if (strcmp(prop, "mbox") == 0)
  1273.     {
  1274.         if (sa_mbox_exists(sactx, user))
  1275.             strcpy(buffer, "CHECKED");
  1276.         else
  1277.             strcpy(buffer, "");
  1278.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1279.             return (SA_FAIL);
  1280.     }
  1281.     else 
  1282.     {
  1283.         sprintf(buffer, "User lookup for property '%s' failed.", prop);
  1284.         sa_log(sactx, buffer);
  1285.         *infop = SA_E_INVALIDDATA;
  1286.         return (SA_FAIL);
  1287.     }
  1288.  
  1289.     return (SA_SUCCEED);
  1290. }
  1291.  
  1292. /*
  1293. **  USER_MAILLIST
  1294. **
  1295. **    List all mail users for delete or update.
  1296. **
  1297. **  Parameters:
  1298. **    sactx        Sambar Server context
  1299. **    saconn        Sambar Server connection
  1300. **    saparams    RPC Parameters
  1301. **    infop        Error parameters
  1302. **
  1303. **  Returns:
  1304. **    SA_SUCCEED | SA_FAIL
  1305. **
  1306. **  Notes:
  1307. **    This list is truncated at 500 names.
  1308. */
  1309. SA_RETCODE SA_PUBLIC
  1310. user_maillist(sactx, saconn, saparams, infop)
  1311. SA_CTX        *sactx;
  1312. SA_CONN        *saconn;
  1313. SA_PARAMS    *saparams;
  1314. SA_INT        *infop;
  1315. {
  1316.     SA_INT            i;
  1317.     SA_INT            numusers;
  1318.     SA_USER            users[500];
  1319.     SA_CHAR            buffer[512];
  1320.  
  1321.     if (sa_passwd_list(sactx, users, 500, &numusers) != SA_SUCCEED)
  1322.     {
  1323.         sa_log(sactx, "user_list(): failure retrieving names list!");
  1324.         return (SA_FAIL);
  1325.     }
  1326.  
  1327.     /* Sort the mail user list alphabetically at this point.            */
  1328.  
  1329.     if (sa_conn_send(saconn, "<TABLE BORDER=0 CELLPADDING=2>\n", SA_NULLTERM) 
  1330.         != SA_SUCCEED)
  1331.     {
  1332.         return (SA_FAIL);
  1333.     }
  1334.  
  1335.     if (sa_conn_send(saconn, 
  1336.         "<TR><TH>User</TH><TH align=center>Mailbox</TH></TR>\n",
  1337.         SA_NULLTERM) != SA_SUCCEED)
  1338.     {
  1339.         return (SA_FAIL);
  1340.     }
  1341.  
  1342.     /*
  1343.     ** Display the mail users
  1344.     */
  1345.     for (i = 0; i < numusers; i++)
  1346.     {
  1347.         sprintf(buffer, "<TR><TD><b>%s</b> </TD><TD>", users[i].username);
  1348.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1349.             return (SA_FAIL);
  1350.  
  1351.         if (sa_mbox_exists(sactx, users[i].username))
  1352.         {
  1353.             sprintf(buffer, 
  1354.                 "<A HREF=\"/session/usermbox?action=delete&username=%s&RCpage=/sysadmin/mail/users.stm\"><font color=#990000>Delete</font></A>",
  1355.                 users[i].username);
  1356.             if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1357.                 return (SA_FAIL);
  1358.         }
  1359.         else
  1360.         {
  1361.             sprintf(buffer, 
  1362.                 "<A HREF=\"/session/usermbox?action=create&username=%s&RCpage=/sysadmin/mail/users.stm\"><font color=#009900>Create</font></A>", 
  1363.                 users[i].username);
  1364.             if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1365.                 return (SA_FAIL);
  1366.         }
  1367.  
  1368.         if (sa_conn_send(saconn, "</TD></TR>\n", SA_NULLTERM) != SA_SUCCEED)
  1369.             return (SA_FAIL);
  1370.     }
  1371.  
  1372.     if (sa_conn_send(saconn, "</TABLE>\n", SA_NULLTERM) != SA_SUCCEED)
  1373.         return (SA_FAIL);
  1374.  
  1375.     return (SA_SUCCEED);
  1376. }
  1377.  
  1378. /*
  1379. **  USER_MBOX
  1380. **
  1381. **    Update an user mailbox
  1382. **
  1383. **  Parameters:
  1384. **    sactx        Sambar Server context
  1385. **    saconn        Sambar Server connection
  1386. **    saparams    RPC Parameters
  1387. **    infop        Error parameters
  1388. **
  1389. **  Returns:
  1390. **    SA_SUCCEED | SA_FAIL
  1391. */
  1392. SA_RETCODE SA_PUBLIC
  1393. user_mailbox(sactx, saconn, saparams, infop)
  1394. SA_CTX        *sactx;
  1395. SA_CONN        *saconn;
  1396. SA_PARAMS    *saparams;
  1397. SA_INT        *infop;
  1398. {
  1399.     SA_BOOL        create;
  1400.     SA_INT        datalen;
  1401.     SA_CHAR        *data;
  1402.     SA_PASSWD    passwd;
  1403.  
  1404.     if (sa_param(sactx, saparams, "action", &data, &datalen) != SA_SUCCEED)
  1405.     {
  1406.         *infop = SA_E_INVALIDDATA;
  1407.         sa_log(sactx, "user_mailbox(): Expected parameter 'action'!");
  1408.         return (SA_FAIL);
  1409.     }
  1410.  
  1411.     if (stricmp(data, "create") == 0)
  1412.     {
  1413.         create = 1;
  1414.     }
  1415.     else if (stricmp(data, "delete") == 0)
  1416.     {
  1417.         create = 0;
  1418.     }
  1419.     else
  1420.     {
  1421.         *infop = SA_E_INVALIDDATA;
  1422.         sa_log(sactx, "user_mailbox(): Parameter 'action' not create/delete!");
  1423.         return (SA_FAIL);
  1424.     }
  1425.     
  1426.     if ((sa_param(sactx, saparams, "username", &data, &datalen) != SA_SUCCEED)
  1427.         || (datalen == 0) || (datalen > SA_MAX_NAME))
  1428.     {
  1429.         *infop = SA_E_INVALIDDATA;
  1430.         sa_log(sactx, "user_mailbox(): Expected parameter 'username'!");
  1431.         return (SA_FAIL);
  1432.     }
  1433.  
  1434.     /* Verify the user account exists.                                    */
  1435.     if (sa_passwd_lookup(sactx, data, datalen, &passwd) == SA_SUCCEED)
  1436.     {
  1437.         /* Create the user mailbox.                                        */
  1438.         if (create)
  1439.         {
  1440.             if (sa_mbox_create(sactx, data) != SA_SUCCEED)
  1441.                 sa_log(sactx, "user_mailbox(): sa_mbox_create() failed!");
  1442.         }
  1443.         else
  1444.         {
  1445.             if (sa_mbox_delete(sactx, data) != SA_SUCCEED)
  1446.                 sa_log(sactx, "user_mailbox(): sa_mbox_delete() failed!");
  1447.         }
  1448.     }
  1449.  
  1450.     return (SA_SUCCEED);
  1451. }
  1452.  
  1453.  
  1454. /*
  1455. **  FTP_CONNECT
  1456. **
  1457. **    Process an FTP Connect request. Verify the username/password against 
  1458. **    the Sambar Server password interfaces and return the root directory
  1459. **    and priviledges.
  1460. **
  1461. **  Parameters:
  1462. **    sactx            Sambar Server Application context to release.
  1463. **    saconn            Sambar Server User Connection handle.
  1464. **    username        Name of the user logging in.
  1465. **    usernamelen        Length of the user name
  1466. **    password        Password of the user logging in.
  1467. **    passwordlen        Length of the password.
  1468. **    ftpresp            FTP response structure.
  1469. **
  1470. **  Return Values:
  1471. **    SA_SUCCESS         Login Accepted.
  1472. **    SA_FAIL            Login Denied.
  1473. */
  1474. SA_RETCODE SA_PUBLIC
  1475. ftp_connect(sactx, name, namelen, password, passwordlen, ftpresp)
  1476. SA_CTX        *sactx;
  1477. SA_CHAR        *name;
  1478. SA_INT        namelen;
  1479. SA_CHAR        *password;
  1480. SA_INT        passwordlen;
  1481. SA_FTP        *ftpresp;
  1482. {
  1483.     SA_BOOL            ntauth;
  1484.     SA_BOOL            status;
  1485.     SA_PASSWD        passwd;
  1486.     SA_CHAR            buffer[512];
  1487.  
  1488.     ntauth = 0;
  1489.     if (sa_ctx_props(sactx, SA_GET, SA_CTXPROP_NTAUTH, buffer, 30, 
  1490.         (SA_INT *)NULL) == SA_SUCCEED)
  1491.     {
  1492.         if (stricmp(name, "true") == 0)
  1493.             ntauth = 1;
  1494.     }
  1495.  
  1496.     if (ntauth)
  1497.     {
  1498.         if ((sa_passwd_verify(sactx, name, namelen, password, passwordlen,
  1499.             &status) != SA_SUCCEED) || (!status))
  1500.         {
  1501.             sprintf(buffer, 
  1502.                 "FTP login for user '%s' failed - bad password (%s)", 
  1503.                 name, password);
  1504.             sa_log(sactx, buffer);
  1505.             return (SA_FAIL);
  1506.         }
  1507.  
  1508.         ftpresp->privs = SA_PRIV_READWRITE;
  1509.         ftpresp->ftpmax = 0;
  1510.  
  1511.         if (sa_ctx_props(sactx, SA_GET, SA_CTXPROP_HOMEDIR, ftpresp->dir, 
  1512.             SA_MAX_NAME, &ftpresp->dirlen) != SA_SUCCEED)
  1513.         {
  1514. #ifdef    WIN32
  1515.             strcpy(ftpresp->dir, "c:/temp");
  1516. #else
  1517.             strcpy(ftpresp->dir, "/tmp");
  1518. #endif
  1519.             ftpresp->dirlen = strlen(ftpresp->dir);
  1520.         }
  1521.     }
  1522.     else
  1523.     {
  1524.         if (sa_passwd_lookup(sactx, name, namelen, &passwd) != SA_SUCCEED)
  1525.         {
  1526.             sprintf(buffer, "FTP login for user '%s' failed.", name);
  1527.             sa_log(sactx, buffer);
  1528.             return (SA_FAIL);
  1529.         }
  1530.  
  1531.         /* Verify the passwords are the same                            */
  1532.         if ((passwd.passwordlen != passwordlen) ||
  1533.             (strncmp(passwd.password, password, passwordlen) != 0))
  1534.         {
  1535.             /* Special case for anonymous user - NULL password match OK    */
  1536.             if ((namelen != 9) || (strncmp(name, "anonymous", 9) != 0))
  1537.             {
  1538.                 sprintf(buffer, 
  1539.                     "FTP login for user '%s' failed - bad password (%s)", 
  1540.                     name, password);
  1541.                 sa_log(sactx, buffer);
  1542.                 return (SA_FAIL);
  1543.             }
  1544.         }
  1545.  
  1546.         /* Return the directory and access priviledges                    */
  1547.         ftpresp->privs = passwd.ftpprivs;
  1548.         ftpresp->ftpmax = passwd.ftpmax;
  1549.         ftpresp->dirlen = passwd.dirlen;
  1550.         if (ftpresp->dirlen > 0)
  1551.             strncpy(ftpresp->dir, passwd.dir, ftpresp->dirlen);
  1552.  
  1553.         ftpresp->dir[ftpresp->dirlen] = '\0';
  1554.     }
  1555.  
  1556. #ifdef DEBUG
  1557.     sprintf(buffer, "FTP User '%s' logged in.", name);
  1558.     sa_log(sactx, buffer);
  1559. #endif    /* DEBUG */
  1560.  
  1561.     return (SA_SUCCEED);
  1562. }
  1563.  
  1564. /*
  1565. **  MAIL_CONNECT
  1566. **
  1567. **    Process an MAIL Connect request. Verify the username/password against 
  1568. **    the Sambar Server password interfaces.
  1569. **
  1570. **  Parameters:
  1571. **    sactx            Sambar Server Application context to release.
  1572. **    saconn            Sambar Server User Connection handle.
  1573. **    username        Name of the user logging in.
  1574. **    usernamelen        Length of the user name
  1575. **    password        Password of the user logging in.
  1576. **    passwordlen        Length of the password.
  1577. **
  1578. **  Return Values:
  1579. **    SA_SUCCESS         Login Accepted.
  1580. **    SA_FAIL            Login Denied.
  1581. */
  1582. SA_RETCODE SA_PUBLIC
  1583. mail_connect(sactx, name, namelen, password, passwordlen)
  1584. SA_CTX        *sactx;
  1585. SA_CHAR        *name;
  1586. SA_INT        namelen;
  1587. SA_CHAR        *password;
  1588. SA_INT        passwordlen;
  1589. {
  1590.     SA_BOOL        status;
  1591.     SA_CHAR        buffer[512];
  1592.  
  1593.     if ((sa_passwd_verify(sactx, name, namelen, password, passwordlen, &status) 
  1594.         != SA_SUCCEED) || (!status))
  1595.     {
  1596.         sprintf(buffer, 
  1597.             "MAIL login for user '%s' failed - bad password (%s)", 
  1598.             name, password);
  1599.         sa_log(sactx, buffer);
  1600.         return (SA_FAIL);
  1601.     }
  1602.  
  1603. #ifdef DEBUG
  1604.     sprintf(buffer, "MAIL User '%s' logged in.", name);
  1605.     sa_log(sactx, buffer);
  1606. #endif    /* DEBUG */
  1607.  
  1608.     return (SA_SUCCEED);
  1609. }
  1610.  
  1611. /*
  1612. **  TELNET_CONNECT
  1613. **
  1614. **    Process an Telnet Connect request. Verify the username/password against 
  1615. **    the Sambar Server password interfaces.
  1616. **
  1617. **  Parameters:
  1618. **    sactx            Sambar Server Application context to release.
  1619. **    saconn            Sambar Server User Connection handle.
  1620. **    username        Name of the user logging in.
  1621. **    usernamelen        Length of the user name
  1622. **    password        Password of the user logging in.
  1623. **    passwordlen        Length of the password.
  1624. **
  1625. **  Return Values:
  1626. **    SA_SUCCESS         Login Accepted.
  1627. **    SA_FAIL            Login Denied.
  1628. */
  1629. SA_RETCODE SA_PUBLIC
  1630. telnet_connect(sactx, name, namelen, password, passwordlen)
  1631. SA_CTX        *sactx;
  1632. SA_CHAR        *name;
  1633. SA_INT        namelen;
  1634. SA_CHAR        *password;
  1635. SA_INT        passwordlen;
  1636. {
  1637.     SA_BOOL        status;
  1638.     SA_CHAR        buffer[512];
  1639.  
  1640.     if ((sa_passwd_verify(sactx, name, namelen, password, passwordlen, &status) 
  1641.         != SA_SUCCEED) || (!status))
  1642.     {
  1643.         sprintf(buffer, 
  1644.             "Telnet login for user '%s' failed - bad password (%s)", 
  1645.             name, password);
  1646.         sa_log(sactx, buffer);
  1647.         return (SA_FAIL);
  1648.     }
  1649.  
  1650. #ifdef DEBUG
  1651.     sprintf(buffer, "Telnet User '%s' logged in.", name);
  1652.     sa_log(sactx, buffer);
  1653. #endif    /* DEBUG */
  1654.  
  1655.     return (SA_SUCCEED);
  1656. }
  1657.  
  1658. /*
  1659. **  GROUP_ADD
  1660. **
  1661. **    Add a new group
  1662. **
  1663. **  Parameters:
  1664. **    sactx        Sambar Server context
  1665. **    saconn        Sambar Server connection
  1666. **    saparams    RPC Parameters
  1667. **    infop        Error parameters
  1668. **
  1669. **  Returns:
  1670. **    SA_SUCCEED | SA_FAIL
  1671. */
  1672. SA_RETCODE SA_PUBLIC
  1673. group_add(sactx, saconn, saparams, infop)
  1674. SA_CTX        *sactx;
  1675. SA_CONN        *saconn;
  1676. SA_PARAMS    *saparams;
  1677. SA_INT        *infop;
  1678. {
  1679.     SA_CHAR        *data;
  1680.     SA_INT        datalen;
  1681.  
  1682.     if (sa_param(sactx, saparams, "groupname", &data, &datalen) != SA_SUCCEED)
  1683.     {
  1684.         *infop = SA_E_INVALIDDATA;
  1685.         sa_log(sactx, "group_add(): Expected parameter 'groupname'!");
  1686.         return (SA_FAIL);
  1687.     }
  1688.     
  1689.     if ((datalen == 0) || (datalen > SA_MAX_NAME))
  1690.     {
  1691.         *infop = SA_E_INVALIDDATA;
  1692.         sa_log(sactx, "group_add(): 'name' field left NULL!");
  1693.         return (SA_FAIL);
  1694.     }
  1695.  
  1696.     /* Can't create the group "other"                                    */
  1697.     if ((datalen == 5) && 
  1698.         (memcmp(data, SA_DEFAULT_GROUP, strlen(SA_DEFAULT_GROUP)) == 0))
  1699.     {
  1700.         *infop = SA_E_INVALIDDATA;
  1701.         sa_log(sactx, "group_add(): 'other' group already exists!");
  1702.         return (SA_FAIL);
  1703.     }
  1704.  
  1705.     if (sa_group_add(sactx, data, datalen) != SA_SUCCEED)
  1706.     {
  1707.         *infop = SA_E_ALREADYDEFINED;
  1708.         sa_log(sactx, "group_add(): sa_group_add() failed (already defined?)");
  1709.         return (SA_FAIL);
  1710.     }
  1711.  
  1712.     return (SA_SUCCEED);
  1713. }
  1714.  
  1715. /*
  1716. **  GROUP_DELETE
  1717. **
  1718. **    Delete an existing group
  1719. **
  1720. **  Parameters:
  1721. **    sactx        Sambar Server context
  1722. **    saconn        Sambar Server connection
  1723. **    saparams    RPC Parameters
  1724. **    infop        Error parameters
  1725. **
  1726. **  Returns:
  1727. **    SA_SUCCEED | SA_FAIL
  1728. **
  1729. **    Notes:
  1730. **    No users can belong to the group.
  1731. */
  1732. SA_RETCODE SA_PUBLIC
  1733. group_delete(sactx, saconn, saparams, infop)
  1734. SA_CTX        *sactx;
  1735. SA_CONN        *saconn;
  1736. SA_PARAMS    *saparams;
  1737. SA_INT        *infop;
  1738. {
  1739.     SA_INT        datalen;
  1740.     SA_CHAR        *data;
  1741.  
  1742.     if (sa_param(sactx, saparams, "groupname", &data, &datalen) != SA_SUCCEED)
  1743.     {
  1744.         *infop = SA_E_INVALIDDATA;
  1745.         sa_log(sactx, "group_delete(): Expected parameter 'groupname'!");
  1746.         return (SA_FAIL);
  1747.     }
  1748.  
  1749.     if ((datalen == 0) || (datalen > SA_MAX_NAME))
  1750.     {
  1751.         *infop = SA_E_INVALIDDATA;
  1752.         sa_log(sactx, "group_delete(): 'groupname' field left NULL!");
  1753.         return (SA_FAIL);
  1754.     }
  1755.  
  1756.     /* Can't delete the group "other"                                    */
  1757.     if ((datalen == 5) && 
  1758.         (memcmp(data, SA_DEFAULT_GROUP, strlen(SA_DEFAULT_GROUP)) == 0))
  1759.     {
  1760.         *infop = SA_E_INVALIDDATA;
  1761.         sa_log(sactx, "group_delete(): 'other' group cannot be deleted!");
  1762.         return (SA_FAIL);
  1763.     }
  1764.  
  1765.     /* Should only be allowed to do this if the group has no users.        */
  1766.     (SA_VOID)sa_group_delete(sactx, data, datalen);
  1767.  
  1768.     return (SA_SUCCEED);
  1769. }
  1770.  
  1771. /*
  1772. **  GROUP_SELECT
  1773. **
  1774. **    List all groups for selection.
  1775. **
  1776. **  Parameters:
  1777. **    sactx        Sambar Server context
  1778. **    saconn        Sambar Server connection
  1779. **    saparams    RPC Parameters
  1780. **    infop        Error parameters
  1781. **
  1782. **  Returns:
  1783. **    SA_SUCCEED | SA_FAIL
  1784. **
  1785. **  Notes:
  1786. **    This list is truncated at 100 names.
  1787. **    The group other always exists and is used for users with unrecognized
  1788. **    group names.
  1789. */
  1790. SA_RETCODE SA_PUBLIC
  1791. group_select(sactx, saconn, saparams, infop)
  1792. SA_CTX        *sactx;
  1793. SA_CONN        *saconn;
  1794. SA_PARAMS    *saparams;
  1795. SA_INT        *infop;
  1796. {
  1797.     SA_INT            i;
  1798.     SA_BOOL            found;
  1799.     SA_BOOL            selected;
  1800.     SA_INT            grouplen;
  1801.     SA_INT            userlen;
  1802.     SA_INT            numgroups;
  1803.     SA_CHAR            *user;
  1804.     SA_PASSWD        passwd;
  1805.     SA_CHAR            group[SA_MAX_NAME + 1];
  1806.     SA_GROUP        groups[100];
  1807.     SA_CHAR            buffer[512];
  1808.  
  1809.     /* If a name is provided make it SELECTED in the OPTION list        */
  1810.     userlen = 0;
  1811.     grouplen = 0;
  1812.     (SA_VOID)sa_param(sactx, saparams, "username", &user, &userlen);
  1813.  
  1814.     if ((userlen > 0) && (userlen < SA_MAX_NAME))
  1815.     {
  1816.         if (sa_passwd_lookup(sactx, user, userlen, &passwd) != SA_SUCCEED)
  1817.         {
  1818.             sprintf(buffer, "User lookup for '%s' failed.", user);
  1819.             sa_log(sactx, buffer);
  1820.             *infop = SA_E_INVALIDDATA;
  1821.             return (SA_FAIL);
  1822.         }
  1823.  
  1824.         grouplen = passwd.grouplen;
  1825.         if (grouplen > 0)
  1826.             memcpy(group, passwd.group, grouplen);
  1827.     }
  1828.  
  1829.     if (sa_group_list(sactx, groups, 100, &numgroups) != SA_SUCCEED)
  1830.     {
  1831.         sa_log(sactx, "group_select(): failure retrieving groups list!");
  1832.         return (SA_FAIL);
  1833.     }
  1834.  
  1835.     /* We could sort the names alphabetically at this point...            */
  1836.  
  1837.     /* Display the list of groups.                                        */
  1838.     found = 0;
  1839.     for (i = 0; i < numgroups; i++)
  1840.     {
  1841.         selected = 0;
  1842.         if ((grouplen > 0) &&
  1843.             (groups[i].namelen == grouplen) &&
  1844.             (memcmp(group, groups[i].name, grouplen) == 0))
  1845.         {
  1846.             selected = 1;
  1847.             found = 1;
  1848.         }
  1849.  
  1850.         sprintf(buffer, "<OPTION %s>%s\n", (selected ? "SELECTED" : ""),
  1851.             groups[i].name);
  1852.  
  1853.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1854.             return (SA_FAIL);
  1855.     }
  1856.  
  1857.     /* The group "other" always exists.                                    */
  1858.     sprintf(buffer, "<OPTION %s>%s\n", (found ? "" : "SELECTED"),
  1859.         SA_DEFAULT_GROUP);
  1860.     if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1861.         return (SA_FAIL);
  1862.  
  1863.     return (SA_SUCCEED);
  1864. }
  1865.  
  1866. /*
  1867. **  GROUP_LIST
  1868. **
  1869. **    List all groups for delete.
  1870. **
  1871. **  Parameters:
  1872. **    sactx        Sambar Server context
  1873. **    saconn        Sambar Server connection
  1874. **    saparams    RPC Parameters
  1875. **    infop        Error parameters
  1876. **
  1877. **  Returns:
  1878. **    SA_SUCCEED | SA_FAIL
  1879. **
  1880. **  Notes:
  1881. **    This list is truncated at 100 names.
  1882. **    The group "other" always exists and is the default group.
  1883. */
  1884. SA_RETCODE SA_PUBLIC
  1885. group_list(sactx, saconn, saparams, infop)
  1886. SA_CTX        *sactx;
  1887. SA_CONN        *saconn;
  1888. SA_PARAMS    *saparams;
  1889. SA_INT        *infop;
  1890. {
  1891.     SA_INT            i;
  1892.     SA_INT            numgroups;
  1893.     SA_GROUP        groups[100];
  1894.     SA_CHAR            buffer[512];
  1895.  
  1896.     if (sa_group_list(sactx, groups, 100, &numgroups) != SA_SUCCEED)
  1897.     {
  1898.         sa_log(sactx, "group_list(): failure retrieving groups list!");
  1899.         return (SA_FAIL);
  1900.     }
  1901.  
  1902.     /* We could sort the list alphabetically at this point.                */
  1903.  
  1904.     /* Display the list of groups.                                        */
  1905.     for (i = 0; i < numgroups; i++)
  1906.     {
  1907.         sprintf(buffer, 
  1908.             "<A HREF=\"/session/delgroup?groupname=%s&RCpage=/sysadmin/usermgmt/grplist.stm\" onClick=\"return confirmDelete()\"><IMG border=0 HEIGHT=20 WIDTH=20 SRC=\"/sysimage/system/trash.gif\"></A> %s<BR>\n",
  1909.             groups[i].name, groups[i].name);
  1910.  
  1911.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  1912.             return (SA_FAIL);
  1913.     }
  1914.  
  1915.     return (SA_SUCCEED);
  1916. }
  1917.