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