clients/mmoira/form_setup.c

   1 /* $Header$
   2  */
   3
   4 #include <stdio.h>
   5 #include <ctype.h>
   6 #include <string.h>
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9 #include <moira.h>
  10 #include <moira_site.h>
  11 #include <Xm/Xm.h>
  12 #include "mmoira.h"
  13
  14
  15 extern char *user, *program_name;
  16 extern EntryForm *MoiraForms[];
  17 EntryForm *GetAndClearForm();
  18
  19 char *user_states[] = { "0 - Registerable",
  20                           "1 - Active",
  21                           "2 - Half Registered",
  22                           "3 - Deleted",
  23                           "4 - Not registerable",
  24                           "5 - Enrolled/Registerable",
  25                           "6 - Enrolled/Not Registerable",
  26                           "7 - Half Enrolled",
  27                           NULL};
  28 char *nfs_states[] = { "0 - Not Allocated",
  29                          "1 - Student",
  30                           "2 - Faculty",
  31                           "4 - Staff",
  32                           "8 - Miscellaneous",
  33                           NULL};
  34
  35
  36 static FixNameCase(form, field)
  37 EntryForm *form;
  38 int field;
  39 {
  40     char fixname[128], buf[256];
  41
  42     strcpy(fixname, stringval(form, field));
  43     FixCase(fixname);
  44     sprintf(buf, "You entered a name which does not follow the capitalization conventions.\nCorrect it to \"%s\"?", fixname);
  45     if (strcmp(fixname, stringval(form, field)) &&
  46         AskQuestion(buf, "fixcase"))
  47       StoreField(form, field, fixname);
  48 }
  49
  50
  51 get_members(argc, argv, sq)
  52 int argc;
  53 char **argv;
  54 struct save_queue *sq;
  55 {
  56     char buf[256];
  57
  58     sprintf(buf, "%s (%s)", argv[0], argv[1]);
  59     sq_save_data(sq, strsave(buf));
  60     return(MR_CONT);
  61 }
  62
  63
  64 /* Deal with AFS cell names */
  65
  66 char *canonicalize_cell(c)
  67 char *c;
  68 {
  69     struct stat stbuf;
  70     char path[512];
  71     int count;
  72
  73     c = strtrim(c);
  74     sprintf(path, "/afs/%s", c);
  75     if (lstat(path, &stbuf) || !stbuf.st_mode&S_IFLNK)
  76       return(c);
  77     count = readlink(path, path, sizeof(path));
  78     if (count < 1) return(c);
  79     path[count] = 0;
  80     free(c);
  81     return(strsave(path));
  82 }
  83
  84
  85 int GetAliasValue(argc, argv, retval)
  86 int argc;
  87 char **argv;
  88 char **retval;
  89 {
  90     *retval = strsave(argv[2]);
  91     return(MR_CONT);
  92 }
  93
  94
  95 static int GetArgv(argc, argv, info)
  96 int argc;
  97 char **argv;
  98 char ***info;
  99 {
 100     int i;
 101     char *malloc();
 102
 103     *info = (char **)malloc((argc + 1) * sizeof(char *));
 104     for (i = 0; i < argc; i++)
 105       (*info)[i] = strsave(argv[i]);
 106     (*info)[i] = NULL;
 107     return(MR_ABORT);
 108 }
 109
 110
 111 MoiraValueChanged(f, prompt)
 112 EntryForm *f;
 113 UserPrompt *prompt;
 114 {
 115     char buf[1024];
 116     char *argv[5], *p, **info;
 117     int i, size, field;
 118     struct save_queue *sq, *s;
 119 #define maybechange(f, n, v)    {if (f->inputlines[n]->insensitive != v) { f->inputlines[n]->insensitive=v; f->inputlines[n]->changed = True; }}
 120
 121     for (field = 0; f->inputlines[field]; field++)
 122       if (prompt == f->inputlines[field]) break;
 123
 124     switch (f->menu->operation) {
 125     case MM_ADD_LIST:
 126     case MM_MOD_LIST:
 127         if (field == L_GROUP)
 128           maybechange(f, L_GID, !boolval(f, L_GROUP));
 129         if (field == L_ACE_TYPE) {
 130             if (!strcmp(stringval(f, L_ACE_TYPE), "NONE"))
 131               maybechange(f, L_ACE_NAME, True)
 132             else
 133               maybechange(f, L_ACE_NAME, False)
 134         }
 135         break;
 136     case MM_ADD_FILSYS:
 137     case MM_MOD_FILSYS:
 138         if (field == FS_TYPE &&
 139             (!strcmp(stringval(f, FS_TYPE), "FSGROUP") ||
 140              !strcmp(stringval(f, FS_TYPE), "MUL") ||
 141              !strcmp(stringval(f, FS_TYPE), "ERR"))) {
 142             maybechange(f, FS_MACHINE+1, True);
 143             maybechange(f, FS_PACK+1, True);
 144             maybechange(f, FS_M_POINT+1, True);
 145             maybechange(f, FS_ACCESS+1, True);
 146             maybechange(f, FS_CREATE+1, True);
 147         } else if (field == FS_TYPE &&
 148                    (!strcmp(stringval(f, FS_TYPE), "NFS") ||
 149                     !strcmp(stringval(f, FS_TYPE), "AFS") ||
 150                     !strcmp(stringval(f, FS_TYPE), "RVD"))) {
 151             maybechange(f, FS_MACHINE+1, False);
 152             maybechange(f, FS_PACK+1, False);
 153             maybechange(f, FS_M_POINT+1, False);
 154             maybechange(f, FS_ACCESS+1, False);
 155             maybechange(f, FS_CREATE+1, False);
 156         }
 157         if (field == FS_NAME && !strcmp(stringval(f, FS_M_POINT+1), "/mit/")) {
 158             sprintf(buf, "/mit/%s", stringval(f, FS_NAME));
 159             StoreField(f, FS_M_POINT+1, buf);
 160         }
 161         if (field == FS_MACHINE+1 && !strcmp(stringval(f, FS_TYPE), "AFS")) {
 162             p = strsave(stringval(f, FS_MACHINE+1));
 163             p = canonicalize_cell(p);
 164             lowercase(p);
 165             StoreField(f, FS_MACHINE+1, p);
 166             free(p);
 167         }
 168         if (field == FS_MACHINE+1 && (!strcmp(stringval(f, FS_TYPE), "NFS") ||
 169                                     !strcmp(stringval(f, FS_TYPE), "RVD"))) {
 170             StoreHost(f, FS_MACHINE+1, &p);
 171         }
 172         if (!strcmp(stringval(f, FS_TYPE), "AFS") &&
 173             *stringval(f, FS_NAME) &&
 174             *stringval(f, FS_MACHINE+1) &&
 175             *stringval(f, /*FS_L_TYPE*/FS_TYPE+1)) {
 176             char *path;
 177             int depth;
 178
 179             sprintf(buf, "%s:%s", stringval(f, FS_MACHINE+1),
 180                     stringval(f, FS_TYPE+1));
 181             argv[0] = buf;
 182             argv[1] = "AFSPATH";
 183             argv[2] = "*";
 184             path = "???";
 185             i = MoiraQuery("get_alias", 3, argv, GetAliasValue, &path);
 186             if (i == MR_SUCCESS) {
 187                 p = strchr(path, ':');
 188                 if (p) {
 189                     *p = 0;
 190                     depth = atoi(++p);
 191                 } else depth = 0;
 192                 sprintf(buf, "/afs/%s/%s", stringval(f, FS_MACHINE+1), path);
 193                 if (depth >= 0) {
 194                     for (p=stringval(f, FS_NAME);
 195                          *p && (p - stringval(f, FS_NAME)) < depth;
 196                          p++) {
 197                         if (islower(*p)) {
 198                             strcat(buf, "/x");
 199                             buf[strlen(buf)-1] = *p;
 200                         } else {
 201                             sprintf(buf, "/afs/%s/%s/other",
 202                                     stringval(f, FS_MACHINE+1), path);
 203                             break;
 204                         }
 205                     }
 206                 } else if (depth = -1) {
 207                     if (isdigit(stringval(f, FS_NAME)[0])) {
 208                         strcat(buf, "/");
 209                         depth = strlen(buf);
 210                         for (p = stringval(f, FS_NAME);
 211                              *p && isdigit(*p);
 212                              p++) {
 213                             buf[depth++] = *p;
 214                             buf[depth] = 0;
 215                         }
 216                     } else
 217                       strcat(buf, "/other");
 218                 } else {
 219                     /* no default */
 220                 }
 221                 strcat(buf, "/");
 222                 strcat(buf, stringval(f, FS_NAME));
 223                 free(path);
 224             } else {
 225                 p = strsave(stringval(f, FS_TYPE+1));
 226                 sprintf(buf, "/afs/%s/%s/%s", stringval(f, FS_MACHINE+1),
 227                         lowercase(p), stringval(f, FS_NAME));
 228                 free(p);
 229             }
 230             StoreField(f, FS_PACK+1, buf);
 231         }
 232         break;
 233     case MM_SET_POBOX:
 234         if (!strcmp(stringval(f, PO_TYPE), "POP")) {
 235             maybechange(f, 2, True);
 236             maybechange(f, 3, False);
 237         } else if (!strcmp(stringval(f, PO_TYPE), "SMTP")) {
 238             maybechange(f, 2, False);
 239             maybechange(f, 3, True);
 240         } else if (!strcmp(stringval(f, PO_TYPE), "NONE")) {
 241             maybechange(f, 2, True);
 242             maybechange(f, 3, True);
 243         }
 244         break;
 245     case MM_ADD_QUOTA:
 246     case MM_MOD_QUOTA:
 247         if (field == Q_FILESYS) {
 248             argv[0] = stringval(f, 0);
 249             i = MoiraQuery("get_filesys_by_label", 1, argv, GetArgv, &info);
 250             if (i == MR_SUCCESS) {
 251                 if (!strcmp(info[FS_TYPE], "AFS")) {
 252                     StoreField(f, 1, "ANY");
 253                 } else if (!strcmp(info[FS_TYPE], "NFS")) {
 254                     argv[0] = strsave(info[FS_MACHINE]);
 255                     argv[1] = strsave(info[FS_PACK]);
 256                     p = strrchr(argv[1], '/');
 257                     if (p) *p = 0;
 258                     for (i = 0; info[i]; i++) free(info[i]);
 259                     free(info);
 260                     i = MoiraQuery("get_nfsphys", 2, argv, GetArgv, &info);
 261                     if (i == MR_SUCCESS) {
 262                         i = atoi(info[NFS_STATUS]);
 263                         if (i & MR_FS_GROUPQUOTA)
 264                           StoreField(f, 1, "GROUP");
 265                         else
 266                           StoreField(f, 1, "USER");
 267                         for (i = 0; info[i]; i++) free(info[i]);
 268                         free(info);
 269                     }
 270                 }
 271             }
 272         }
 273         if (!strcmp(stringval(f, Q_TYPE), "ANY"))
 274           maybechange(f, Q_NAME, True)
 275         else
 276           maybechange(f, Q_NAME, False)
 277         break;
 278     case MM_ADD_ZEPHYR:
 279     case MM_MOD_ZEPHYR:
 280         if (!strcmp(stringval(f, ZA_XMT_TYPE), "NONE"))
 281           maybechange(f, ZA_XMT_ID, True)
 282         else
 283           maybechange(f, ZA_XMT_ID, False)
 284         if (!strcmp(stringval(f, ZA_SUB_TYPE), "NONE"))
 285           maybechange(f, ZA_SUB_ID, True)
 286         else
 287           maybechange(f, ZA_SUB_ID, False)
 288         if (!strcmp(stringval(f, ZA_IWS_TYPE), "NONE"))
 289           maybechange(f, ZA_IWS_ID, True)
 290         else
 291           maybechange(f, ZA_IWS_ID, False)
 292         if (!strcmp(stringval(f, ZA_IUI_TYPE), "NONE"))
 293           maybechange(f, ZA_IUI_ID, True)
 294         else
 295           maybechange(f, ZA_IUI_ID, False)
 296         break;
 297     case MM_ADD_USER:
 298         FixNameCase(f, U_LAST);
 299         FixNameCase(f, U_FIRST);
 300         FixNameCase(f, U_MIDDLE);
 301         break;
 302     case MM_SHOW_USER:
 303         FixNameCase(f, 1);
 304         FixNameCase(f, 2);
 305         break;
 306     case MM_ADD_FSGROUP:
 307         argv[0] = stringval(f, 0);
 308         sq = sq_create();
 309         i = MoiraQuery("get_fsgroup_members", 1, argv, get_members, (char *)sq);
 310         if (i) {
 311             com_err(program_name, i, " retrieving filesystem group members");
 312             break;
 313         }
 314         size = 1;
 315         for (s = sq->q_next; s->q_next != sq; s = s->q_next)
 316           size++;
 317         if (f->inputlines[2]->keywords)
 318           free(f->inputlines[2]->keywords);
 319         f->inputlines[2]->keywords = (char **)malloc(sizeof(char *)*(size+2));
 320         if (f->inputlines[2]->keywords == NULL) {
 321             display_error("Out of memory while fetching members");
 322             return;
 323         }
 324         f->inputlines[2]->keywords[0] = "[First]";
 325         for (i = 0; i < size; i++)
 326           sq_get_data(sq, &f->inputlines[2]->keywords[i+1]);
 327         f->inputlines[2]->keywords[i+1] = NULL;
 328         f->inputlines[2]->changed = 1;
 329         sq_destroy(sq);
 330         RemakeRadioField(f, 2);
 331         break;
 332     case MM_DEL_FSGROUP:
 333         argv[0] = stringval(f, 0);
 334         sq = sq_create();
 335         i = MoiraQuery("get_fsgroup_members", 1, argv, get_members, (char *)sq);
 336         if (i) {
 337             com_err(program_name, i, " retrieving filesystem group members");
 338             break;
 339         }
 340         size = 1;
 341         for (s = sq->q_next; s->q_next != sq; s = s->q_next)
 342           size++;
 343         if (f->inputlines[1]->keywords)
 344           free(f->inputlines[1]->keywords);
 345         f->inputlines[1]->keywords = (char **)malloc(sizeof(char *)*(size+1));
 346         if (f->inputlines[1]->keywords == NULL) {
 347             display_error("Out of memory while fetching members");
 348             return;
 349         }
 350         for (i = 0; i < size; i++)
 351           sq_get_data(sq, &f->inputlines[1]->keywords[i]);
 352         f->inputlines[1]->keywords[i] = NULL;
 353         f->inputlines[1]->changed = 1;
 354         sq_destroy(sq);
 355         RemakeRadioField(f, 1);
 356         break;
 357     case MM_MOV_FSGROUP:
 358         argv[0] = stringval(f, 0);
 359         sq = sq_create();
 360         i = MoiraQuery("get_fsgroup_members", 1, argv, get_members, (char *)sq);
 361         if (i) {
 362             com_err(program_name, i, " retrieving filesystem group members");
 363             break;
 364         }
 365         size = 1;
 366         for (s = sq->q_next; s->q_next != sq; s = s->q_next)
 367           size++;
 368         if (f->inputlines[1]->keywords)
 369           free(f->inputlines[1]->keywords);
 370         f->inputlines[1]->keywords = (char **)malloc(sizeof(char *)*(size+1));
 371         if (f->inputlines[1]->keywords == NULL) {
 372             display_error("Out of memory while fetching members");
 373             return;
 374         }
 375         if (f->inputlines[2]->keywords)
 376           free(f->inputlines[2]->keywords);
 377         f->inputlines[2]->keywords = (char **)malloc(sizeof(char *)*(size+2));
 378         if (f->inputlines[2]->keywords == NULL) {
 379             display_error("Out of memory while fetching members");
 380             return;
 381         }
 382         f->inputlines[2]->keywords[0] = "[First]";
 383         for (i = 0; i < size; i++) {
 384             sq_get_data(sq, &f->inputlines[1]->keywords[i]);
 385             f->inputlines[2]->keywords[i+1] = f->inputlines[1]->keywords[i];
 386         }
 387         f->inputlines[1]->keywords[i] = NULL;
 388         f->inputlines[2]->keywords[i+1] = NULL;
 389         f->inputlines[1]->changed = 1;
 390         f->inputlines[2]->changed = 1;
 391         sq_destroy(sq);
 392         RemakeRadioField(f, 1);
 393         RemakeRadioField(f, 2);
 394         break;
 395     default:
 396         return;
 397     }
 398     UpdateForm(f);
 399 }
 400
 401
 402 /* Called when a menu item is selected. */
 403
 404 MoiraMenuRequest(menu)
 405 MenuItem        *menu;
 406 {
 407     EntryForm *f;
 408
 409     f = GetAndClearForm(menu->form);
 410     if (f == NULL) {
 411         if (!strcmp(menu->form, "0"))
 412           MoiraMenuComplete(menu);
 413         else
 414           display_error("Sorry, unable to process that request (no form registered).");
 415         return;
 416     }
 417
 418     switch (menu->operation) {
 419     case MM_SHOW_USER:
 420         GetKeywords(f, 4, "class");
 421         f->inputlines[1]->valuechanged = MoiraValueChanged;
 422         f->inputlines[2]->valuechanged = MoiraValueChanged;
 423         break;
 424     case MM_ADD_USER:
 425         StoreField(f, U_NAME, UNIQUE_LOGIN);
 426         StoreField(f, U_UID, UNIQUE_UID);
 427         StoreField(f, U_SHELL, "/bin/csh");
 428         StoreField(f, U_STATE, user_states[US_NO_LOGIN_YET]);
 429         f->inputlines[U_STATE]->keywords = user_states;
 430         f->inputlines[U_LAST]->valuechanged = MoiraValueChanged;
 431         f->inputlines[U_FIRST]->valuechanged = MoiraValueChanged;
 432         f->inputlines[U_MIDDLE]->valuechanged = MoiraValueChanged;
 433         GetKeywords(f, U_CLASS, "class");
 434         break;
 435     case MM_SET_POBOX:
 436         GetKeywords(f, 1, "pobox");
 437         GetKeywords(f, 3, "poserver");
 438         f->inputlines[PO_TYPE]->valuechanged = MoiraValueChanged;
 439         break;
 440     case MM_ADD_FILSYS:
 441         StoreField(f, FS_TYPE, "AFS");
 442         StoreField(f, FS_M_POINT+1, "/mit/");
 443         StoreField(f, FS_MACHINE+1, "athena.mit.edu");
 444         StoreField(f, FS_ACCESS+1, "w");
 445         StoreField(f, FS_OWNER+1, user);
 446         StoreField(f, FS_OWNERS+1, user);
 447         boolval(f, FS_CREATE+1) = TRUE;
 448         GetKeywords(f, FS_TYPE, "filesys");
 449         GetKeywords(f, FS_ACCESS+1, "fs_access_AFS");
 450         GetKeywords(f, FS_TYPE+1, "lockertype");
 451         f->inputlines[FS_TYPE]->valuechanged = MoiraValueChanged;
 452         f->inputlines[FS_TYPE+1]->valuechanged = MoiraValueChanged;
 453         f->inputlines[FS_NAME]->valuechanged = MoiraValueChanged;
 454         f->inputlines[FS_MACHINE+1]->valuechanged = MoiraValueChanged;
 455         break;
 456     case MM_ADD_FSGROUP:
 457         if (f->inputlines[2]->keywords)
 458           free(f->inputlines[2]->keywords);
 459         f->inputlines[2]->keywords = (char **)malloc(sizeof(char*)*2);
 460         f->inputlines[2]->keywords[0] = "[First]";
 461         f->inputlines[2]->keywords[1] = NULL;
 462         f->inputlines[0]->valuechanged = MoiraValueChanged;
 463         break;
 464     case MM_DEL_FSGROUP:
 465         if (f->inputlines[1]->keywords)
 466           free(f->inputlines[1]->keywords);
 467         f->inputlines[1]->keywords = (char **)malloc(sizeof(char*)*2);
 468         f->inputlines[1]->keywords[0] = "[Placeholder]";
 469         f->inputlines[1]->keywords[1] = NULL;
 470         f->inputlines[0]->valuechanged = MoiraValueChanged;
 471         break;
 472     case MM_MOV_FSGROUP:
 473         if (f->inputlines[1]->keywords)
 474           free(f->inputlines[1]->keywords);
 475         f->inputlines[1]->keywords = (char **)malloc(sizeof(char*)*2);
 476         f->inputlines[1]->keywords[0] = "[Placeholder]";
 477         f->inputlines[1]->keywords[1] = NULL;
 478         if (f->inputlines[2]->keywords)
 479           free(f->inputlines[2]->keywords);
 480         f->inputlines[2]->keywords = (char **)malloc(sizeof(char*)*2);
 481         f->inputlines[2]->keywords[0] = "[First]";
 482         f->inputlines[2]->keywords[1] = NULL;
 483         f->inputlines[0]->valuechanged = MoiraValueChanged;
 484         break;
 485     case MM_ADD_NFS:
 486         StoreField(f, 1, "/u1/lockers");
 487         StoreField(f, 2, "/dev/");
 488         StoreField(f, 5, "0");
 489         StoreField(f, 6, "0");
 490         StoreField(f, 3, nfs_states[1]);
 491         f->inputlines[3]->keywords = nfs_states;
 492         break;
 493     case MM_ADD_QUOTA:
 494     case MM_DEL_QUOTA:
 495     case MM_MOD_QUOTA:
 496         GetKeywords(f, 1, "quota_type");
 497         f->inputlines[Q_FILESYS]->valuechanged = MoiraValueChanged;
 498         f->inputlines[Q_TYPE]->valuechanged = MoiraValueChanged;
 499         break;
 500     case MM_SHOW_ACE_USE:
 501         StoreField(f, 0, "USER");
 502         GetKeywords(f, 0, "ace_type");
 503         break;
 504     case MM_ADD_LIST:
 505         boolval(f, L_ACTIVE) = TRUE;
 506         boolval(f, L_MAILLIST) = TRUE;
 507         StoreField(f, L_GID, UNIQUE_GID);
 508         StoreField(f, L_ACE_TYPE, "USER");
 509         GetKeywords(f, L_ACE_TYPE, "ace_type");
 510         f->inputlines[L_GID]->insensitive = True;
 511         f->inputlines[L_GROUP]->valuechanged = MoiraValueChanged;
 512         f->inputlines[L_ACE_TYPE]->valuechanged = MoiraValueChanged;
 513         break;
 514     case MM_SHOW_MEMBERS:
 515         GetKeywords(f, 1, "member");
 516         break;
 517     case MM_ADD_MEMBER:
 518     case MM_DEL_MEMBER:
 519         GetKeywords(f, 1, "member");
 520         break;
 521     case MM_DEL_ALL_MEMBER:
 522         boolval(f, 2) = TRUE;
 523         GetKeywords(f, 0, "member");
 524         break;
 525     case MM_ADD_MACH:
 526         GetKeywords(f, 1, "mac_type");
 527         break;
 528     case MM_ADD_PCAP:
 529         StoreField(f, PCAP_SPOOL_DIR, "/usr/spool/printer/");
 530         boolval(f, PCAP_AUTH) = TRUE;
 531         StoreField(f, PCAP_PRICE, "10");
 532         break;
 533     case MM_ADD_SERVICE:
 534         StoreField(f, SVC_INTERVAL, "1430");
 535         StoreField(f, SVC_TARGET, "/tmp/");
 536         StoreField(f, SVC_SCRIPT, "/moira/bin/");
 537         StoreField(f, 4, "UNIQUE");
 538         StoreField(f, 6, "NONE");
 539         GetKeywords(f, 4, "service");
 540         GetKeywords(f, 6, "ace_type");
 541         break;
 542     case MM_SHOW_ALIAS:
 543         StoreField(f, 2, "*");
 544         GetKeywords(f, 1, "alias");
 545         break;
 546     case MM_ADD_ZEPHYR:
 547         GetKeywords(f, 1, "ace_type");
 548         GetKeywords(f, 3, "ace_type");
 549         GetKeywords(f, 5, "ace_type");
 550         GetKeywords(f, 7, "ace_type");
 551         f->inputlines[ZA_XMT_TYPE]->valuechanged = MoiraValueChanged;
 552         f->inputlines[ZA_SUB_TYPE]->valuechanged = MoiraValueChanged;
 553         f->inputlines[ZA_IWS_TYPE]->valuechanged = MoiraValueChanged;
 554         f->inputlines[ZA_IUI_TYPE]->valuechanged = MoiraValueChanged;
 555         break;
 556     }
 557
 558     f->menu = menu;
 559     if (tty)
 560       TtyForm(f);
 561     else
 562       DisplayForm(f);
 563 }
 564
 565
 566 /* Find a form by name.  Returns a pointer to the form or NULL on error. */
 567
 568 EntryForm *GetForm(name)
 569 char *name;
 570 {
 571     EntryForm **fp;
 572
 573     for (fp = MoiraForms; *fp; fp++)
 574       if (!strcmp((*fp)->formname, name))
 575         break;
 576     return(*fp);
 577 }
 578
 579
 580 /* Find a form by name and clear all of its fields.  Returns a pointer
 581  * to the form or NULL on error.
 582  */
 583
 584 EntryForm *GetAndClearForm(name)
 585 char *name;
 586 {
 587     EntryForm **fp;
 588     UserPrompt *p, **pp;
 589     static BottomButton **buttons = NULL;
 590     int MoiraFormComplete(), MoiraFormApply();
 591     int button_callback(), help_form_callback();
 592
 593     for (fp = MoiraForms; *fp; fp++)
 594       if (!strcmp((*fp)->formname, name))
 595         break;
 596     if (*fp == (EntryForm *)NULL)
 597       return(NULL);
 598
 599     for (pp = (*fp)->inputlines; p = *pp; pp++) {
 600         switch (p->type) {
 601         case FT_STRING:
 602         case FT_KEYWORD:
 603             if (p->returnvalue.stringvalue)
 604               free(p->returnvalue.stringvalue);
 605             p->returnvalue.stringvalue = (char *)malloc(MAXFIELDSIZE);
 606             if (p->returnvalue.stringvalue == NULL) {
 607                 fprintf(stderr, "Moira: out of memory\n");
 608                 return(NULL);
 609             }
 610             *(p->returnvalue.stringvalue) = '\0';
 611             break;
 612         case FT_BOOLEAN:
 613             p->returnvalue.booleanvalue = False;
 614             break;
 615         case FT_NUMBER:
 616             p->returnvalue.integervalue = 0;
 617             break;
 618         }
 619     }
 620     if (!tty && buttons == NULL) {
 621         buttons = (BottomButton **)malloc(5 * sizeof(BottomButton *));
 622         buttons[0] = (BottomButton *)malloc(sizeof(BottomButton));
 623         buttons[0]->label = "OK";
 624         buttons[0]->returnfunction = MoiraFormComplete;
 625         buttons[1] = (BottomButton *)malloc(sizeof(BottomButton));
 626         buttons[1]->label = "Apply";
 627         buttons[1]->returnfunction = MoiraFormApply;
 628         buttons[2] = (BottomButton *)malloc(sizeof(BottomButton));
 629         buttons[2]->label = "Cancel";
 630         buttons[2]->returnfunction = button_callback;
 631         buttons[3] = (BottomButton *)malloc(sizeof(BottomButton));
 632         buttons[3]->label = "Help";
 633         buttons[3]->returnfunction = help_form_callback;
 634         buttons[4] = NULL;
 635     }
 636     (*fp)->buttons = buttons;
 637     (*fp)->extrastuff = NULL;
 638     return(*fp);
 639 }
 640
 641
 642 /* Store a string into a given field in a form. */
 643
 644 StoreField(form, field, value)
 645 EntryForm *form;
 646 int field;
 647 char *value;
 648 {
 649     strncpy(form->inputlines[field]->returnvalue.stringvalue,
 650             value, MAXFIELDSIZE);
 651 }
 652
 653
 654 char *StringValue(form, field)
 655 EntryForm *form;
 656 int field;
 657 {
 658     switch (form->inputlines[field]->type) {
 659     case FT_STRING:
 660     case FT_KEYWORD:
 661         return(stringval(form, field));
 662     case FT_BOOLEAN:
 663         return(boolval(form, field) ? "1" : "0");
 664     }
 665 }
 666
 667
 668 StoreHost(form, field, dest)
 669 EntryForm *form;
 670 int field;
 671 char **dest;
 672 {
 673     char *s;
 674
 675     s = strsave(stringval(form, field));
 676     s = canonicalize_hostname(s);
 677     StoreField(form, field, s);
 678     form->inputlines[field]->changed = True;
 679     UpdateForm(form);
 680     free(s);
 681     *dest = stringval(form, field);
 682 }
 683
 684
 685 /* Helper routine for GetKeywords() */
 686
 687 static get_alias(argc, argv, sq)
 688 int argc;
 689 char **argv;
 690 struct save_queue *sq;
 691 {
 692     sq_save_data(sq, strsave(argv[2]));
 693 #ifdef DEBUG
 694     printf("found keyword %s\n", argv[2]);
 695 #endif
 696     return(MR_CONT);
 697 }
 698
 699 static get_sloc(argc, argv, sq)
 700 int argc;
 701 char **argv;
 702 struct save_queue *sq;
 703 {
 704     sq_save_data(sq, strsave(argv[1]));
 705 #ifdef DEBUG
 706     printf("found sloc %s\n", argv[1]);
 707 #endif
 708     return(MR_CONT);
 709 }
 710
 711
 712 /* Retrieve possible keyword values from Moira and store them in the specified
 713  * field of the form.  Returns 0 if successful, -1 if not.
 714  */
 715
 716 static struct save_queue *cache = NULL;
 717 struct cache_elem { char *name; char **values; };
 718
 719 int GetKeywords(form, field, name)
 720 EntryForm *form;
 721 int field;
 722 char *name;
 723 {
 724     struct save_queue *sq, *s;
 725     struct cache_elem *ce;
 726     int i, size, stat;
 727     char *argv[4];
 728
 729     /* init cache */
 730     if (cache == NULL)
 731       cache = sq_create();
 732     cache->q_lastget = NULL;
 733
 734     if (!strcmp(name, "fsgroup")) {
 735         form->inputlines[field]->keywords = NULL;
 736     }
 737
 738     /* look through cache */
 739     while (sq_get_data(cache, &ce))
 740       if (!strcmp(ce->name, name)) {
 741           form->inputlines[field]->keywords = ce->values;
 742           return(0);
 743       }
 744
 745     /* not in cache, do query */
 746     sq = sq_create();
 747     if (!strcmp(name, "poserver")) {
 748         argv[0] = "POP";
 749         stat = MoiraQuery("get_server_locations", 1, argv, get_sloc,
 750                           (char *)sq);
 751         if (stat) {
 752             com_err(program_name, stat, "retrieving service locations");
 753             return(-1);
 754         }
 755     } else {
 756         argv[0] = name;
 757         argv[1] = "TYPE";
 758         argv[2] = "*";
 759         stat = MoiraQuery("get_alias", 3, argv, get_alias, (char *)sq);
 760         if (stat) {
 761             com_err(program_name, stat, "retrieving keyword values");
 762             return(-1);
 763         }
 764     }
 765
 766     size = 1;
 767     for (s = sq->q_next; s->q_next != sq; s = s->q_next)
 768       size++;
 769 #ifdef DEBUG
 770     printf("Found %d keywords of type %s\n", size, name);
 771 #endif
 772
 773     /* transform query data into proper malloc'ed structure */
 774     ce = (struct cache_elem *) malloc(sizeof(struct cache_elem));
 775     if (ce == NULL) {
 776         display_error("Out of memory while fetching keywords");
 777         return(-1);
 778     }
 779     ce->name = name;
 780     ce->values = (char **) malloc(sizeof(char *) * (size + 1));
 781     if (ce->values == NULL) {
 782         display_error("Out of memory while fetching keywords");
 783         return(-1);
 784     }
 785     for (i = 0; i < size; i++)
 786       sq_get_data(sq, &(ce->values[i]));
 787     ce->values[i] = NULL;
 788     sq_destroy(sq);
 789
 790     /* put it in the cache */
 791     sq_save_data(cache, ce);
 792
 793     /* and return answer */
 794     form->inputlines[field]->keywords = ce->values;
 795     return(0);
 796 }
 797
 798 CacheNewValue(form, field, name, value)
 799 EntryForm *form;
 800 int field;
 801 char *name;
 802 char *value;
 803 {
 804     struct save_queue *sq;
 805     struct cache_elem *ce;
 806     int size;
 807
 808     /* init cache */
 809     if (cache == NULL)
 810       cache = sq_create();
 811     cache->q_lastget = NULL;
 812
 813     /* find entry in cache */
 814     while (sq_get_data(cache, &ce))
 815       if (!strcmp(ce->name, name))
 816         break;
 817
 818     /* get its size */
 819     for (size = 0; ce->values[size]; size++);
 820
 821     /* add new keyword */
 822     ce->values = (char **)realloc(ce->values, sizeof(char *) * (size + 2));
 823     ce->values[size] = strsave(value);
 824     ce->values[size + 1] = NULL;
 825
 826 #ifdef DEBUG
 827     printf("CacheNewValue(%x, %d, %s, %s)\n", form, field, name, value);
 828     printf("  form is %x (%s)\n", form, form->formname);
 829     printf("  field is %d (%s)\n", field, form->inputlines[field]->prompt);
 830     printf("  keywords: ");
 831     for (size = 0; ce->values[size]; size++) printf("%s ", ce->values[size]);
 832     printf("\n");
 833 #endif /* DEBUG */
 834
 835     /* new update form */
 836     form->inputlines[field]->keywords = ce->values;
 837     if (!tty) RemakeRadioField(form, field);
 838 }