home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #1 / NN_1993_1.iso / spool / vmsnet / sources / 474 < prev    next >
Encoding:
Internet Message Format  |  1993-01-05  |  47.8 KB

  1. Path: sparky!uunet!wupost!cs.utexas.edu!swrinde!network.ucsd.edu!mvb.saic.com!vmsnet-sources
  2. From: tanner@cerritos.edu
  3. Newsgroups: vmsnet.sources
  4. Subject: DWProfile V3.3, part 03/06
  5. Message-ID: <9908592@MVB.SAIC.COM>
  6. Date: Mon, 04 Jan 1993 20:47:05 GMT
  7. Organization: Cerritos College, Norwalk CA
  8. Lines: 1408
  9. Approved: Mark.Berryman@Mvb.Saic.Com
  10.  
  11. Submitted-by: tanner@cerritos.edu
  12. Posting-number: Volume 4, Issue 28
  13. Archive-name: dwprofile/part03
  14.  
  15. -+-+-+-+-+-+-+-+ START OF PART 3 -+-+-+-+-+-+-+-+
  16. X    ident_dsc.dsc$w_length = strlen(select_ptr->name);
  17. X    switch (select_data`5Bselect_index`5D.type) `7B
  18. X    case DWP_ALPHA:
  19. X        if (select_data`5Bselect_index`5D.code == UAI$_USERNAME) `7B
  20. X            matched = (str$match_wild(&ident_dsc, &select_dsc) == STR$_MATCH
  21. V);
  22. X            break;
  23. X        `7D
  24. X        else `7B
  25. X            itmlst`5B0`5D.buflen = select_data`5Bselect_index`5D.size;
  26. X            itmlst`5B0`5D.itmcode = select_data`5Bselect_index`5D.code;
  27. X            itmlst`5B0`5D.bufadr = match_string;
  28. X            itmlst`5B0`5D.retadr = 0;
  29. X            itmlst`5B1`5D.buflen = 0;
  30. X            itmlst`5B1`5D.itmcode = 0;
  31. X            status = sys$getuai(0, 0, &ident_dsc, &itmlst, 0, 0, 0);
  32. X            if ((status & 7) != SS$_NORMAL) `7B
  33. X                sprintf(message, "Username %s does not exist", select_ptr->n
  34. Vame);
  35. X                DWPerror("Find", message, resource_data.find_interval);
  36. X                break;
  37. X            `7D
  38. X            match_string`5B8`5D = ' ';    /* make sure ' ' */
  39. X            match_string`5B9`5D = '\0';   /* make sure null */
  40. X            sptr = strchr(match_string, ' ');
  41. X            if (sptr) *sptr = '\0';
  42. X            match_dsc.dsc$w_length = strlen(match_string);
  43. X            matched = (str$match_wild(&match_dsc, &select_dsc) == STR$_MATCH
  44. V);
  45. X            break;
  46. X        `7D
  47. X    case DWP_LALPHA:
  48. X        itmlst`5B0`5D.buflen = select_data`5Bselect_index`5D.size;
  49. X        itmlst`5B0`5D.itmcode = select_data`5Bselect_index`5D.code;
  50. X        itmlst`5B0`5D.bufadr = match_string;
  51. X        itmlst`5B0`5D.retadr = &length;
  52. X        itmlst`5B1`5D.buflen = 0;
  53. X        itmlst`5B1`5D.itmcode = 0;
  54. X        status = sys$getuai(0, 0, &ident_dsc, &itmlst, 0, 0, 0);
  55. X        if ((status & 7) != SS$_NORMAL) `7B
  56. X            sprintf(message, "Username %s does not exist", select_ptr->name)
  57. V;
  58. X            DWPerror("Find", message, resource_data.find_interval);
  59. X            break;
  60. X        `7D
  61. X        match_string`5Blength`5D = ' ';    /* make sure ' ' */
  62. X        match_string`5Blength+1`5D = '\0';   /* make sure null */
  63. X        strcpy(match_string, unpad(match_string));  /* get rid of length byt
  64. Ve */
  65. X        match_dsc.dsc$w_length = strlen(match_string);
  66. X        matched = (str$match_wild(&match_dsc, &select_dsc) == STR$_MATCH);
  67. X        break;
  68. X    case DWP_UIC:
  69. X        itmlst`5B0`5D.buflen = select_data`5Bselect_index`5D.size;
  70. X        itmlst`5B0`5D.itmcode = select_data`5Bselect_index`5D.code;
  71. X        itmlst`5B0`5D.bufadr = &uic;
  72. X        itmlst`5B0`5D.retadr = &length;
  73. X        itmlst`5B1`5D.buflen = 0;
  74. X        itmlst`5B1`5D.itmcode = 0;
  75. X        status = sys$getuai(0, 0, &ident_dsc, &itmlst, 0, 0, 0);
  76. X        if ((status & 7) != SS$_NORMAL) `7B
  77. X            sprintf(message, "Username %s does not exist", select_ptr->name)
  78. V;
  79. X            DWPerror("Find", message, resource_data.find_interval);
  80. X            break;
  81. X        `7D
  82. X        /* convert UIC to text and do text wildcard match */
  83. X        sprintf(match_string, "`5B%o,%o`5D", uic >> 16, uic & 0xFFFF);
  84. X        match_dsc.dsc$w_length = strlen(match_string);
  85. X        matched = (str$match_wild(&match_dsc, &select_dsc) == STR$_MATCH);
  86. X        break;
  87. X    case DWP_DATE:
  88. X        itmlst`5B0`5D.buflen = select_data`5Bselect_index`5D.size;
  89. X        itmlst`5B0`5D.itmcode = select_data`5Bselect_index`5D.code;
  90. X        itmlst`5B0`5D.bufadr = match_string;
  91. X        itmlst`5B0`5D.retadr = 0;
  92. X        itmlst`5B1`5D.buflen = 0;
  93. X        itmlst`5B1`5D.itmcode = 0;
  94. X        status = sys$getuai(0, 0, &ident_dsc, &itmlst, 0, 0, 0);
  95. X        if ((status & 7) != SS$_NORMAL) `7B
  96. X            sprintf(message, "Username %s does not exist", select_ptr->name)
  97. V;
  98. X            DWPerror("Find", message, resource_data.find_interval);
  99. X            break;
  100. X        `7D
  101. X        matched = (!memcmp(match_string, select_string,
  102. X                           select_data`5Bselect_index`5D.size));
  103. X        break;
  104. X    case DWP_RINT:
  105. X        /* special test - the only test of a RINT is logfails > 0 */
  106. X        itmlst`5B0`5D.buflen = select_data`5Bselect_index`5D.size;
  107. X        itmlst`5B0`5D.itmcode = select_data`5Bselect_index`5D.code;
  108. X        itmlst`5B0`5D.bufadr = &logfails;
  109. X        itmlst`5B0`5D.retadr = &length;
  110. X        itmlst`5B1`5D.buflen = 0;
  111. X        itmlst`5B1`5D.itmcode = 0;
  112. X        status = sys$getuai(0, 0, &ident_dsc, &itmlst, 0, 0, 0);
  113. X        if ((status & 7) != SS$_NORMAL) `7B
  114. X            sprintf(message, "Username %s does not exist", select_ptr->name)
  115. V;
  116. X            DWPerror("Find", message, resource_data.find_interval);
  117. X            break;
  118. X        `7D
  119. X        matched = logfails;
  120. X        break;
  121. X    `7D
  122. X    if (matched) `7B
  123. X        if (found_add)
  124. X            found_add = found_add->next = XtNew(ident);
  125. X        else
  126. X            found_add = found_list.next = XtNew(ident);
  127. X        found_add->name = XtNewString(select_ptr->name);
  128. X        found_add->next = NULL;
  129. X    `7D
  130. X    if (select_ptr = select_ptr->next)
  131. X        return FALSE;
  132. X    else `7B
  133. X        if (!found_ptr->next) `7B  /* no more to display */
  134. X            XtSetSensitive(button_array`5Bfind_button`5D, OFF);  /* 'find' b
  135. Vutton is inactive */
  136. X            XtSetSensitive(button_array`5Bfind_menu`5D, OFF);
  137. X        `7D
  138. X        progress(NULL);
  139. X        find_work_proc_id = (XtWorkProcId) 0;
  140. X        return TRUE;
  141. X    `7D
  142. X`7D
  143. X
  144. X
  145. X/*
  146. X *  Parse textual date to 64 bit binary value`20
  147. X *  Returns false if illegal date
  148. X */
  149. X
  150. Xstatic Boolean parse_date(Cardinal value)
  151. X`7B
  152. X    Cardinal status, count = 0;
  153. X    String str;
  154. X    $DESCRIPTOR(time_dsc, uafdata`5Bvalue`5D.sdata);
  155. X
  156. X    if (!strlen(uafdata`5Bvalue`5D.sdata)) `7B /* empty date means (none) */
  157. X        memset(uafdata`5Bvalue`5D.sdata, 0, 8);  /* make date 'none' */
  158. X        return TRUE;
  159. X    `7D
  160. X    /* default expiration date to midnight instead of current time */
  161. X    for (str = uafdata`5Bvalue`5D.sdata; str;) `7B
  162. X        if((str = strchr(str, ':')) == NULL)
  163. X            break;  /* no more colons */
  164. X        count++;    /* count the colons in date */
  165. X        str++;      /* skip over the colon we just counted */
  166. X    `7D
  167. X    if (count < 1)              /* no hh:mm:ss.cc */
  168. X        strcat(uafdata`5Bvalue`5D.sdata, " 00:00:00.00");
  169. X    else if (count < 2)         /* no ss.cc */
  170. X        strcat(uafdata`5Bvalue`5D.sdata, ":00.00");
  171. X    time_dsc.dsc$w_length = strlen(uafdata`5Bvalue`5D.sdata);
  172. X    status = sys$bintim(&time_dsc, &uafdata`5Bvalue`5D.sdata);
  173. X    /* .sdata will now contain the 64-bit system time */
  174. X    return (status == SS$_NORMAL);
  175. X`7D
  176. X
  177. X
  178. X/*
  179. X *  Parse textual UIC to binary value`20
  180. X *  Returns false if illegal UIC format
  181. X */
  182. X
  183. Xstatic Boolean parse_uic(int code)
  184. X`7B
  185. X    Cardinal status, grp = 0, mem = 0;
  186. X
  187. X    status = sscanf(uafdata`5Bcode`5D.sdata, "`5B%o,%o`5D", &grp, &mem);
  188. X    if (status != 2) /* try without `5B`5D */
  189. X        status = sscanf(uafdata`5Bcode`5D.sdata, "%o,%o", &grp, &mem);
  190. X    uafdata`5BUAI$_UIC`5D.idata = (grp << 16) + mem;
  191. X    return (status == 2);
  192. X`7D
  193. X
  194. X
  195. X/*
  196. X *  Build the list of accounts for accounts_box
  197. X */
  198. X
  199. Xstatic void build_accounts()
  200. X`7B
  201. X    ident *ptr;
  202. X    XmString *items;
  203. X    Widget list;
  204. X    Cardinal ind;
  205. X
  206. X    if (!accounts_box `7C`7C !XtIsManaged(accounts_box))
  207. X        return; /* box isn't there */
  208. X
  209. X    list = XmSelectionBoxGetChild(accounts_box, XmDIALOG_LIST);
  210. X    XmListDeleteAllItems(list);
  211. X    items = (XmString *)XtCalloc(account_count, sizeof(XmString));
  212. X    for (ptr = ident_list, ind = 0; ptr; ptr = ptr->next)
  213. X        if (ptr->status == account)
  214. X            items`5Bind++`5D = XmStringCreateSimple(ptr->name);
  215. X    XmListAddItems(list, items, ind, 0);
  216. X    for (ind = 0; ind < account_count; ind++)
  217. X        XmStringFree(items`5Bind`5D);
  218. X    XtFree(items);
  219. X`7D
  220. X
  221. X
  222. X/*
  223. X *  Show the progress of 'Find Next'
  224. X */
  225. X
  226. Xstatic void progress(ident *location)
  227. X`7B
  228. X    static Widget progress_box = NULL;
  229. X    XmString xmstr;
  230. X    char str`5B80`5D;
  231. X    Cardinal ac, count, pct;
  232. X    static int old_pct = -1;
  233. X    Arg arglist`5B10`5D;
  234. X    ident *ptr;
  235. X    Display *display;
  236. X    Window window;
  237. X
  238. X    if (progress_id) `7B
  239. X        XtRemoveTimeOut(progress_id);   /* clear out any old timers */
  240. X        progress_id = (XtIntervalId) 0;
  241. X    `7D
  242. X
  243. X    if (!location) `7B  /* location = null means pop down box */
  244. X        if (progress_box && XtIsManaged(progress_box))
  245. X            XtUnmanageChild(progress_box);
  246. X        return;
  247. X    `7D
  248. X
  249. X    if (!progress_box) `7B
  250. X        ac = 0;
  251. X        xmstr = XmStringCreateSimple("DWProfile: Find progress");
  252. X        XtSetArg(arglist`5Bac`5D, XmNheight, 112); ac++;
  253. X        XtSetArg(arglist`5Bac`5D, XmNwidth, 224); ac++;
  254. X        XtSetArg(arglist`5Bac`5D, XmNresizePolicy, XmRESIZE_NONE); ac++;
  255. X        XtSetArg(arglist`5Bac`5D, XmNdialogTitle, xmstr); ac++;
  256. X        progress_box = XmCreateWorkingDialog(dwprofile_main, "progress_box",
  257. V arglist, ac);
  258. X        XmStringFree(xmstr);
  259. X        XtUnmanageChild(XmMessageBoxGetChild(progress_box, XmDIALOG_OK_BUTTO
  260. VN));
  261. X        XtUnmanageChild(XmMessageBoxGetChild(progress_box, XmDIALOG_HELP_BUT
  262. VTON));
  263. X        XtAddCallback(progress_box, XmNcancelCallback, FindCancelCallback, N
  264. VULL);
  265. X    `7D
  266. X
  267. X    if (!XtIsManaged(progress_box))
  268. X        XtManageChild(progress_box);    /* pop up progress box */
  269. X
  270. X    if (location->next) `7B
  271. X        for (ptr = ident_list, count = 0; ptr != location; ptr = ptr->next)
  272. X            if (ptr->status == uic_ident)
  273. X                count++;   /* count idents read so far */
  274. X        pct = (count * 100) / uic_count;  /* idents read as a percent */
  275. X        if (pct != old_pct) `7B
  276. X            old_pct = pct;
  277. X            sprintf(str, "%d%% of identifiers searched", pct);
  278. X            xmstr = XmStringCreateSimple(str);
  279. X            ac = 0;
  280. X            XtSetArg(arglist`5Bac`5D, XmNmessageString, xmstr); ac++;
  281. X            XtSetValues(progress_box, arglist, ac);
  282. X            XmStringFree(xmstr);
  283. X        `7D
  284. X        /* leave this dialog box up, call Find in 1 second */
  285. X        progress_id = XtAppAddTimeOut(context, 1000, Find, NULL);
  286. X
  287. X    `7D
  288. X    else  /* this is the last item, pop down the box */
  289. X        XtUnmanageChild(progress_box);
  290. X`7D
  291. X
  292. X
  293. X
  294. X/*** Event Handlers ***/
  295. X
  296. X/*
  297. X *  Called by mouse button and exposure events in access windows
  298. X */
  299. X
  300. Xstatic XtEventHandler access_handler(Widget w, XtPointer data,
  301. X                                     XButtonEvent *event, Boolean *dispatch)
  302. X`7B
  303. X    Cardinal wi, hour;
  304. X    static Boolean mode;
  305. X
  306. X    /* find the uai code for this event */
  307. X    for (wi = UAI$_NETWORK_ACCESS_P;
  308. X        widget_array`5Bwi`5D != w && wi <= UAI$_REMOTE_ACCESS_S; wi++)
  309. X        /* just calc index */ ;
  310. X
  311. X    switch (event->type) `7B
  312. X    case Expose :
  313. X        update_time(wi);    /* update the exposed window */
  314. X        break;
  315. X    case ButtonPress :
  316. X        uafdata`5Bwi`5D.changed = TRUE;
  317. X        hour = event->x / resource_data.hour_size;
  318. X        mode = uafdata`5Bwi`5D.idata >> hour & 1 `5E 1;    /* flip current *
  319. V/
  320. X    case MotionNotify:         /* common code for ButtonPress, Motion */
  321. X        hour = event->x / resource_data.hour_size;
  322. X        XFillRectangle(event->display, event->window,
  323. X                       mode ? gc_clear : gc_draw,
  324. X                       hour * resource_data.hour_size, 0,
  325. X                       resource_data.hour_size, k_hours_height);
  326. X        if (mode)
  327. X            uafdata`5Bwi`5D.idata `7C= 1 << hour;
  328. X        else
  329. X            uafdata`5Bwi`5D.idata &= `7E(1 << hour);
  330. X        break;
  331. X    `7D
  332. X`7D
  333. X
  334. X
  335. X/*
  336. X *  Called by event handler on MB3 push
  337. X */
  338. X
  339. Xstatic XtEventHandler popup_handler(Widget widget, Widget popup_menu,
  340. X                                    XButtonPressedEvent *event, Boolean *dis
  341. Vpatch)
  342. X`7B
  343. X    if (event->button != Button3)
  344. X        return;
  345. X    XmMenuPosition(popup_menu, event);     /* position popup menu */
  346. X    XtManageChild(popup_menu);             /* manage it */
  347. X`7D
  348. X
  349. X
  350. X/*
  351. X *  Called when a return is pressed in a text widget
  352. X */
  353. X
  354. Xstatic XtActionProc return_key(Widget widget, XKeyPressedEvent *event,    `2
  355. V0
  356. X                               String *str, Cardinal *args)
  357. X`7B
  358. X    if (widget == widget_array`5BUAI$_USERNAME`5D)
  359. X        Read(NULL, NULL, NULL); /* read new username */
  360. X    else if (widget == widget_array`5BUAI$_ACCOUNT`5D) `7B
  361. X        calc_uic();                         /* figure out a new uic */
  362. X        trans_uic(uafdata`5BUAI$_UIC`5D.idata); /* in case calc_uic didn't *
  363. V/
  364. X    `7D
  365. X`7D
  366. X
  367. X
  368. X/*
  369. X * Select menu shortcut
  370. X * Set up select_data index for call to Select()
  371. X */
  372. X
  373. Xstatic XtActionProc select_key(Widget widget, XKeyPressedEvent *event,    `2
  374. V0
  375. X                               String *str, Cardinal *args)
  376. X`7B
  377. X    Cardinal wi, si;
  378. X
  379. X    /* find the widget_array index */
  380. X    for(wi = 0; items`5Bwi`5D.code; wi++)
  381. X        if (widget == widget_array`5Bwi`5D)
  382. X            break;
  383. X    /* find the select_data index */
  384. X    for(si = 0; select_data`5Bsi`5D.code; si++)
  385. X        if (wi == select_data`5Bsi`5D.code)
  386. X            break;
  387. X    /* call Select() with the index */
  388. X    if (select_data`5Bsi`5D.code)
  389. X        Select(NULL, &si, NULL);
  390. X`7D
  391. X
  392. X
  393. X
  394. X/*** Callbacks ***/
  395. X
  396. X/*
  397. X *  Called by 'Quit' menu item
  398. X */
  399. X
  400. Xstatic XtCallbackProc Quit(Widget widget, XtPointer data,    `20
  401. X            XmPushButtonCallbackStruct *reason)
  402. X`7B
  403. X    exit();
  404. X`7D
  405. X
  406. X
  407. X/*
  408. X *  Read in the uaf entry specified by username; if error, load DEFAULT
  409. X *  Called by 'Read' menu or return_key from username text widget
  410. X */
  411. X
  412. Xstatic XtCallbackProc Read(Widget widget, XtPointer data,
  413. X            XmPushButtonCallbackStruct *reason)
  414. X`7B
  415. X    String str;
  416. X
  417. X    XDefineCursor(top_display, top_window, wait_cursor);
  418. X    XFlush(top_display);
  419. X    str = XmTextGetString(widget_array`5BUAI$_USERNAME`5D);
  420. X    if (!get_record(str)) `7B
  421. X        if (get_record("DEFAULT")) `7B
  422. X            set_defaults(str);
  423. X            DWPerror("Read", "Username does not exist, defaults applied",
  424. X                     resource_data.read_interval);
  425. X        `7D
  426. X        else
  427. X            DWPerror("Read", "Cannot read username DEFAULT", 0);
  428. X    `7D
  429. X    XtFree(str);
  430. X    XUndefineCursor(top_display, top_window);
  431. X`7D
  432. X
  433. X
  434. X/*
  435. X *  Find the next UAF entry that matches the current criteria
  436. X *
  437. X *  Note: UAF entry is defined as a UIC-type identifier.
  438. X *  If a UAF entry does not have an identifier of the same
  439. X *   name, it will not be searched.
  440. X *
  441. X *  Called by 'Find' menu item
  442. X */
  443. X
  444. Xstatic XtCallbackProc Find(Widget widget, XtPointer data,
  445. X            XmPushButtonCallbackStruct *reason)
  446. X`7B
  447. X
  448. X    /* if nothing found yet and still looking, mark time */
  449. X    if (!found_ptr->next && find_work_proc_id) `7B
  450. X        progress(select_ptr);
  451. X        return;
  452. X    `7D
  453. X
  454. X#ifdef DEBUG
  455. X    if (!XtIsSensitive(button_array`5Bfind_button`5D)) `7B  /* stray timer c
  456. Vallback */
  457. X        printf("Find() callback with button insensitive\n");
  458. X        return;
  459. X    `7D
  460. X#endif
  461. X
  462. X    progress(NULL);  /* something is found or search done, get rid of progre
  463. Vss box */
  464. X
  465. X    /* get next found ident and display it */
  466. X    if (found_ptr->next) `7B
  467. X        found_ptr = found_ptr->next;
  468. X        get_record(found_ptr->name);
  469. X        if (!found_ptr->next && !find_work_proc_id) `7B        /* last item
  470. V on found list? */
  471. X            XtSetSensitive(button_array`5Bfind_button`5D, OFF);
  472. X            XtSetSensitive(button_array`5Bfind_menu`5D, OFF);
  473. X        `7D
  474. X    `7D
  475. X    /* we get here when something allows a Find Next with nothing to get */
  476. X    else `7B
  477. X#ifdef DEBUG
  478. X        printf("This shouldn't happen, tell me\n");
  479. X#endif
  480. X        XtSetSensitive(button_array`5Bfind_button`5D, OFF);  /* turn off but
  481. Vton */
  482. X        XtSetSensitive(button_array`5Bfind_menu`5D, OFF);
  483. X    `7D
  484. X`7D
  485. X
  486. X
  487. X/*
  488. X *  Update the UAF record for 'username'
  489. X *  Called by 'Write' menu item
  490. X */
  491. X
  492. Xstatic XtCallbackProc Write(Widget widget, XtPointer data,
  493. X            XmPushButtonCallbackStruct *reason)
  494. X`7B
  495. X    Cardinal ind, pad, item, value, status, dd, hh, mm, ss, cc,
  496. X             holder`5B2`5D = `7B0, 0`7D;
  497. X    ident *ptr, *prev, *next;
  498. X    held_ident *hptr, *prev_hptr, *tmp_hptr;
  499. X    char command`5B200`5D = "", temp`5B100`5D;
  500. X    $DESCRIPTOR(acct_dsc, uafdata`5BUAI$_USERNAME`5D.sdata);
  501. X
  502. X    XDefineCursor(top_display, top_window, wait_cursor);
  503. X    XFlush(top_display);
  504. X
  505. X    /* make sure uafdata`5Buai$_uic`5D.idata matches the text */
  506. X    if (!parse_uic(UAI$_UIC))  /* if not good uic */
  507. X        uafdata`5BUAI$_UIC`5D.idata = 0;  /* force error */
  508. X   `20
  509. X    if (!strlen(uafdata`5BUAI$_OWNER`5D.sdata) `7C`7C
  510. X        !strncmp(uafdata`5BUAI$_ACCOUNT`5D.sdata, "DEFAULT", 7) `7C`7C
  511. X        !strncmp(uafdata`5BUAI$_DEFDIR`5D.sdata, "`5BUSER`5D", 6) `7C`7C
  512. X        !strlen(unpad(uafdata`5BUAI$_DEFDEV`5D.sdata)) `7C`7C
  513. X        !strlen(unpad(uafdata`5BUAI$_DEFDIR`5D.sdata)) `7C`7C
  514. X        !uafdata`5BUAI$_UIC`5D.idata) `7B
  515. X            DWPerror("Write","Bad Owner, Account, UIC or Directory name", 0)
  516. V;
  517. X            XUndefineCursor(top_display, top_window);
  518. X            return;
  519. X    `7D
  520. X    /* item code UAI$_USERNAME is never used by sys$setuai */
  521. X    if (uafdata`5BUAI$_USERNAME`5D.changed) `7B
  522. X        if (uafdata`5BUAI$_USERNAME`5D.sdata`5B0`5D &&
  523. X                uafdata`5BUAI$_UIC`5D.idata) `7B    /* create a new user */
  524. X            sprintf(temp, "$ UAF ADD %s/UIC=%s", uafdata`5BUAI$_USERNAME`5D.
  525. Vsdata,
  526. X                    uafdata`5BUAI$_UIC`5D.sdata);
  527. X            strcpy(command, temp);
  528. X            uafdata`5BUAI$_USERNAME`5D.changed = FALSE;
  529. X            uafdata`5BUAI$_UIC`5D.changed = FALSE;
  530. X            if (uafdata`5BUAI$_ACCOUNT`5D.sdata`5B0`5D) `7B
  531. X                sprintf(temp, "/ACCOUNT=%s", uafdata`5BUAI$_ACCOUNT`5D.sdata
  532. V);
  533. X                strcat(command, temp);
  534. X                uafdata`5BUAI$_ACCOUNT`5D.changed = FALSE;
  535. X            `7D
  536. X            if (uafdata`5BUAI$_PWD`5D.sdata`5B0`5D) `7B
  537. X                sprintf(temp, "/PASSWORD=%s", uafdata`5BUAI$_PWD`5D.sdata);
  538. X                strcat(command, temp);
  539. X                uafdata`5BUAI$_PWD`5D.changed = FALSE;
  540. X            `7D
  541. X            spawn_dcl(command);
  542. X        `7D
  543. X        else `7B
  544. X            DWPerror("Write","No username or no UIC", 0);
  545. X            XUndefineCursor(top_display, top_window);
  546. X            return;
  547. X        `7D
  548. X    `7D
  549. X    else `7B
  550. X        /* check for password change; is setuai able to do this now? */
  551. X        if (uafdata`5BUAI$_PWD`5D.changed &&
  552. X          uafdata`5BUAI$_USERNAME`5D.sdata`5B0`5D &&
  553. X          uafdata`5BUAI$_PWD`5D.sdata`5B0`5D) `7B
  554. X            sprintf(temp, "$ UAF MODIFY %s/PASSWORD=%s\n",
  555. X                    uafdata`5BUAI$_USERNAME`5D.sdata, uafdata`5BUAI$_PWD`5D.
  556. Vsdata);
  557. X            strcat(command, temp);
  558. X            uafdata`5BUAI$_PWD`5D.changed = FALSE;
  559. X        `7D
  560. X        /* check for device/directory change; the directory tree needs to be
  561. V moved */
  562. X        if ((uafdata`5BUAI$_DEFDEV`5D.changed && strlen(uafdata`5BUAI$_DEFDE
  563. VV`5D.sdata))
  564. X            `7C`7C (uafdata`5BUAI$_DEFDIR`5D.changed && strlen(uafdata`5BUAI
  565. V$_DEFDIR`5D.sdata))) `7B
  566. X            sprintf(temp, "$ @DWPUID:MOVE_DIRECTORY %s %s %s %s\n",
  567. X                    unpad(uafdata`5BUAI$_DEFDEV`5D.odata),
  568. X                    unpad(uafdata`5BUAI$_DEFDIR`5D.odata),
  569. X                    unpad(uafdata`5BUAI$_DEFDEV`5D.sdata),
  570. X                    unpad(uafdata`5BUAI$_DEFDIR`5D.sdata));
  571. X            strcat(command, temp);
  572. X            /* update the old values */
  573. X            strcpy(uafdata`5BUAI$_DEFDEV`5D.odata, unpad(uafdata`5BUAI$_DEFD
  574. VEV`5D.sdata));
  575. X            strcpy(uafdata`5BUAI$_DEFDIR`5D.odata, unpad(uafdata`5BUAI$_DEFD
  576. VIR`5D.sdata));
  577. X        `7D
  578. X        /* check for UIC change;  old identifier must be deleted, new ident
  579. V created */
  580. X        /* let authorize handle it.  new UIC will be added to idents list be
  581. Vlow */
  582. X        if (uafdata`5BUAI$_UIC`5D.changed &&
  583. X          uafdata`5BUAI$_UIC`5D.idata) `7B
  584. X            sprintf(temp, "$ UAF MODIFY %s/UIC=%s\n",
  585. X                    uafdata`5BUAI$_USERNAME`5D.sdata, uafdata`5BUAI$_UIC`5D.
  586. Vsdata);
  587. X            strcat(command, temp);
  588. X            uafdata`5BUAI$_UIC`5D.changed = FALSE;
  589. X            sprintf(temp, "$ @DWPUID:RESETOWNER %s%s %s\n",
  590. X                    unpad(uafdata`5BUAI$_DEFDEV`5D.sdata),
  591. X                    unpad(uafdata`5BUAI$_DEFDIR`5D.sdata),
  592. X                    uafdata`5BUAI$_USERNAME`5D.sdata);
  593. X            strcat(command, temp);
  594. X        `7D
  595. X        /* any of these generated a DCL command? */
  596. X        if (strlen(command))
  597. X            spawn_dcl(command);
  598. X    `7D
  599. X    item = 0;
  600. X    for (ind = 0; value = items`5Bind`5D.code; ind++) `7B
  601. X        if (value && uafdata`5Bvalue`5D.changed) `7B
  602. X            uafdata`5Bvalue`5D.changed = FALSE;
  603. X            itmlst`5Bitem`5D.itmcode = value;
  604. X            itmlst`5Bitem`5D.buflen = items`5Bind`5D.size;
  605. X            switch (items`5Bind`5D.type) `7B
  606. X            case DWP_LALPHA: /* if it's been changed, it has no length byte
  607. V */
  608. X                if (value == UAI$_DEFDIR && strlen(uafdata`5Bvalue`5D.sdata)
  609. V) `7B
  610. X                    if (uafdata`5Bvalue`5D.sdata`5B0`5D != '`5B') `7B
  611. X                        sprintf(temp, "`5B%s", uafdata`5Bvalue`5D.sdata);
  612. X                        strcpy(uafdata`5Bvalue`5D.sdata, temp);
  613. X                    `7D
  614. X                    if (uafdata`5Bvalue`5D.sdata`5Bstrlen(uafdata`5Bvalue`5D
  615. V.sdata)-1`5D
  616. X                        != '`5D')
  617. X                        strcat(uafdata`5Bvalue`5D.sdata, "`5D");    /* dir h
  618. Vas `5B`5D */
  619. X                `7D
  620. X                if (value == UAI$_DEFDEV &&
  621. X                        strlen(uafdata`5Bvalue`5D.sdata) &&
  622. X                        uafdata`5Bvalue`5D.sdata`5Bstrlen(uafdata`5Bvalue`5D
  623. V.sdata)-1`5D
  624. X                        != ':')
  625. X                    strcat(uafdata`5Bvalue`5D.sdata, ":");    /* ends with '
  626. V:' */
  627. X                strcpy(temp, uafdata`5Bvalue`5D.sdata);
  628. X                uafdata`5Bvalue`5D.sdata`5B0`5D = strlen(temp);   /* make le
  629. Vngth byte */
  630. X                for (pad = strlen(temp); pad < items`5Bind`5D.size; pad++)
  631. X                    temp`5Bpad`5D = ' ';     /* pad with spaces, no null */
  632. X                strncpy(&uafdata`5Bvalue`5D.sdata`5B1`5D, temp, items`5Bind`
  633. V5D.size);
  634. X                itmlst`5Bitem`5D.bufadr = uafdata`5Bvalue`5D.sdata;
  635. X                break;
  636. X            case DWP_ALPHA:   /* account */
  637. X                for (pad = 0; pad < items`5Bind`5D.size && uafdata`5Bvalue`5
  638. VD.sdata`5Bpad`5D;)
  639. X                    pad++;  /* skip over string */
  640. X                for (; pad < items`5Bind`5D.size; pad++)
  641. X                    uafdata`5Bvalue`5D.sdata`5Bpad`5D = ' '; /* pad with spa
  642. Vces, no null */
  643. X            case DWP_PRIV:    /* common code for all alphabetic, priv */
  644. X                itmlst`5Bitem`5D.bufadr = uafdata`5Bvalue`5D.sdata;
  645. X                break;
  646. X            case DWP_INT:
  647. X                sscanf(uafdata`5Bvalue`5D.sdata, "%d", &uafdata`5Bvalue`5D.i
  648. Vdata);
  649. X            case DWP_TIME:    /* these have correct data in .idata */
  650. X            case DWP_FLAG:
  651. X            case DWP_PRIME:
  652. X                itmlst`5Bitem`5D.bufadr = &uafdata`5Bvalue`5D.idata;
  653. X                break;
  654. X            case DWP_CPU:
  655. X                dd = hh = mm = ss = cc = 0;
  656. X                status = sscanf(uafdata`5Bvalue`5D.sdata, "%d %02d:%02d:%02d
  657. V.%02d",
  658. X                                                      &dd, &hh, &mm, &ss, &c
  659. Vc);
  660. X                if (status < 4) `7B /* try hh:mm:ss */
  661. X                    dd = hh = mm = ss = cc = 0;
  662. X                    status = sscanf(uafdata`5Bvalue`5D.sdata, "%02d:%02d:%02
  663. Vd.%02d",
  664. X                                                            &hh, &mm, &ss, &
  665. Vcc);
  666. X                `7D
  667. X                if (status < 3) `7B /* try mm:ss */
  668. X                    dd = hh = mm = ss = cc = 0;
  669. X                    status = sscanf(uafdata`5Bvalue`5D.sdata, "%02d:%02d.%02
  670. Vd",
  671. X                                                            &mm, &ss, &cc);
  672. X                `7D
  673. X                if (status < 2) `7B /* try ss */
  674. X                    dd = hh = mm = ss = cc = 0;
  675. X                    status = sscanf(uafdata`5Bvalue`5D.sdata, "%d.%02d",
  676. X                                                            &ss, &cc);
  677. X                `7D
  678. X                uafdata`5Bvalue`5D.idata = dd * 8640000 + hh * 360000 +
  679. X                                       mm * 6000 + ss * 100 + cc;
  680. X                itmlst`5Bitem`5D.bufadr = &uafdata`5Bvalue`5D.idata;
  681. X                break;
  682. X            case DWP_DATE: `7B
  683. X                /* This one's kinda tricky, .sdata can contain a 64-bit */
  684. X                /* system time or a string.  At this point it should contain
  685. V */
  686. X                /* a string, since .changed is set only in WidgetChanged */
  687. X                if (parse_date(value))
  688. X                    itmlst`5Bitem`5D.bufadr = &uafdata`5Bvalue`5D.sdata;
  689. X                else `7B
  690. X                    DWPerror("Write","Illegal date format", 0);
  691. X                    --item;
  692. X                `7D
  693. X                break;
  694. X            `7D
  695. X            case DWP_UIC:
  696. X                itmlst`5Bitem`5D.bufadr = &uafdata`5Bvalue`5D.idata;
  697. X                break;
  698. X            `7D
  699. X            itmlst`5Bitem`5D.retadr = 0;
  700. X            item++;
  701. X        `7D
  702. X    `7D
  703. X    itmlst`5Bitem`5D.itmcode = itmlst`5Bitem`5D.buflen = 0;    /* end the li
  704. Vst */
  705. X    acct_dsc.dsc$w_length = strlen(uafdata`5BUAI$_USERNAME`5D.sdata);
  706. X    if (item) `7B
  707. X        status = sys$setuai(0, 0, &acct_dsc, &itmlst, 0, 0, 0);
  708. V              `20
  709. X        if (status != SS$_NORMAL)
  710. X            DWPmsg("Write/SETUAI", status);
  711. X        else
  712. X            DWPerror("Write", "SETUAI successful", resource_data.write_inter
  713. Vval);
  714. X    `7D
  715. X    update_strings();    /* undo the padding of strings done above */
  716. X
  717. X    holder`5B0`5D = uafdata`5BUAI$_UIC`5D.idata;
  718. X    for (hptr = held_list, prev_hptr = NULL; hptr;) `7B
  719. X        tmp_hptr = NULL;
  720. X        switch (hptr->status) `7B
  721. X        case add_ident:  /* ident flagged for pending add */
  722. X            status = sys$add_holder(hptr->identifier, &holder, 0);
  723. X            if (status != SS$_NORMAL)
  724. X                DWPmsg("Write/ADD_HOLDER", status);
  725. X            else
  726. X                DWPerror("Write","ADD_HOLDER successful", resource_data.writ
  727. Ve_interval);
  728. X            hptr->status = original;  /* ident is now permanently held */
  729. X            break;
  730. X        case del_orig:  /* ident flagged for pending delete */
  731. X            status = sys$rem_holder(hptr->identifier, &holder);
  732. X            if (status != SS$_NORMAL)
  733. X                DWPmsg("Write/REM_HOLDER", status);
  734. X            else
  735. X                DWPerror("Write","REM_HOLDER successful", resource_data.writ
  736. Ve_interval);
  737. X            if (prev_hptr)
  738. X                prev_hptr->next = hptr->next;  /* remove node from list */
  739. X            else
  740. X               held_list = hptr->next;
  741. X            tmp_hptr = hptr;
  742. X            break;
  743. X        case original: /* originally held id, no need to add it again */
  744. X            break;
  745. X        `7D
  746. X        prev_hptr = hptr;
  747. X        hptr = hptr->next;
  748. X        if (tmp_hptr)
  749. X            XtFree(tmp_hptr);
  750. X    `7D
  751. X
  752. X        /* add identifier to list */
  753. X        for (ptr = ident_list, prev = NULL; ptr; prev = ptr, ptr = ptr->next
  754. V)
  755. X            if (strcmp(ptr->name, uafdata`5BUAI$_USERNAME`5D.sdata) >= 0) br
  756. Veak;
  757. X        /* if ptr = 0, no identifier was higher than username
  758. X           if strcmp > 0, ptr->name is the next higher name
  759. X           if strcmp = 0, names matched; don't insert
  760. X        */
  761. X        if (!ptr `7C`7C strcmp(ptr->name, uafdata`5BUAI$_USERNAME`5D.sdata))
  762. V `7B
  763. X            next = ptr;
  764. X            ptr = XtNew(ident);
  765. X            if (prev)
  766. X                prev->next = ptr;
  767. X            else
  768. X                ident_list = ptr;
  769. X            ptr->name = XtNewString(uafdata`5BUAI$_USERNAME`5D.sdata);
  770. X            ptr->next = next;
  771. X            ptr->identifier = uafdata`5BUAI$_UIC`5D.idata;
  772. X            ptr->status = uic_ident;
  773. X            uic_count++;
  774. X        `7D
  775. X        /* add group identifier to list */
  776. X        for (ptr = ident_list, prev = NULL; ptr; prev = ptr, ptr = ptr->next
  777. V)`20
  778. X            if (strcmp(ptr->name, uafdata`5BUAI$_ACCOUNT`5D.sdata) >= 0) bre
  779. Vak;
  780. X        if (!ptr `7C`7C strcmp(ptr->name, uafdata`5BUAI$_ACCOUNT`5D.sdata))
  781. V `7B
  782. X            next = ptr;
  783. X            ptr = XtNew(ident);
  784. X            if (prev)
  785. X                prev->next = ptr;
  786. X            else
  787. X                ident_list = ptr;
  788. X            ptr->name = XtNewString(uafdata`5BUAI$_ACCOUNT`5D.sdata);
  789. X            ptr->next = next;
  790. X            ptr->identifier = (uafdata`5BUAI$_UIC`5D.idata `7C 0xFFFF);
  791. X            ptr->status = account;
  792. X            account_count++;
  793. X            if (accounts_box && XtIsManaged(accounts_box)) `7B
  794. X               build_accounts();  /* reload accounts info */
  795. X            `7D
  796. X        `7D
  797. X
  798. X    XUndefineCursor(top_display, top_window);
  799. X`7D
  800. X
  801. X
  802. X/*
  803. X *  Delete a UAF record
  804. X *  Called by 'Remove' menu item
  805. X */
  806. X
  807. Xstatic XtCallbackProc Remove(Widget widget, XtPointer data,
  808. X            XmPushButtonCallbackStruct *reason)
  809. X`7B
  810. X    Cardinal ac;
  811. X    Arg arglist`5B5`5D;
  812. X    char msg`5B30`5D;
  813. X    XmString xmstr;
  814. X    String str;
  815. X    static Widget caution_box = NULL;
  816. X
  817. X    str = XmTextGetString(widget_array`5BUAI$_USERNAME`5D);
  818. X    strcpy(msg, str);
  819. X    XtFree(str);
  820. X    if (!get_record(msg)) `7B
  821. X        sprintf(msg, "User %s doesn't exist", uafdata`5BUAI$_USERNAME`5D.sda
  822. Vta);
  823. X        DWPerror("Remove", msg, 0);
  824. X        return;
  825. X    `7D
  826. X    if (!caution_box) `7B
  827. X        ac = 0;
  828. X        xmstr = XmStringCreateSimple("DWProfile: Remove");
  829. X        XtSetArg(arglist`5Bac`5D, XmNdialogTitle, xmstr); ac++;
  830. X        XtSetArg(arglist`5Bac`5D, XmNdialogStyle, XmDIALOG_APPLICATION_MODAL
  831. V); ac++;
  832. X        caution_box = XmCreateWarningDialog(dwprofile_main, "caution_box", a
  833. Vrglist, ac);
  834. X        XmStringFree(xmstr);
  835. X        XtUnmanageChild(XmMessageBoxGetChild(caution_box, XmDIALOG_HELP_BUTT
  836. VON));
  837. X        XtAddCallback(caution_box, XmNokCallback, CautionCallback, NULL);
  838. X    `7D
  839. X    ac = 0;
  840. X    sprintf(msg, "Remove user %s?", uafdata`5BUAI$_USERNAME`5D.sdata);
  841. X    xmstr = XmStringCreateSimple(msg);
  842. X    XtSetArg(arglist`5Bac`5D, XmNmessageString, xmstr); ac++;
  843. X    XtSetValues(caution_box, arglist, ac);
  844. X    XmStringFree(xmstr);
  845. X    XtManageChild(caution_box);    /* popup modal caution box */
  846. X`7D
  847. X
  848. X
  849. X/*
  850. X *  Issue REMOVE UAF command if OK button pressed in caution box
  851. X */
  852. X
  853. Xstatic XtCallbackProc CautionCallback(Widget widget, XtPointer data,
  854. X            XmPushButtonCallbackStruct *reason)
  855. X`7B
  856. X    char command`5B20`5D;
  857. X
  858. X    XtUnmanageChild(widget);
  859. X    XDefineCursor(top_display, top_window, wait_cursor);
  860. X    XFlush(top_display);
  861. X    if (reason->reason == XmCR_OK
  862. X            && uafdata`5BUAI$_USERNAME`5D.sdata`5B0`5D) `7B
  863. X        sprintf(command, "$ UAF REMOVE %s", uafdata`5BUAI$_USERNAME`5D.sdata
  864. V);
  865. X        spawn_dcl(command);
  866. X        get_record("");
  867. X    `7D
  868. X    XUndefineCursor(top_display, top_window);
  869. X`7D
  870. X
  871. X
  872. X/*
  873. X *  Remove the error message widget when ack'ed or timed out
  874. X */
  875. X
  876. Xstatic XtTimerCallbackProc MessageCallback(Widget widget, XtPointer data)
  877. X`7B
  878. X    XtUnmanageChild(widget); /* popdown message box */
  879. X    XtRemoveTimeOut(timeout_id); /* clear out timer */
  880. X`7D
  881. X
  882. X
  883. X/*
  884. X *  Stop the idents work proc when 'reading idents' WorkingDialog widget is
  885. V cancelled
  886. X */
  887. X
  888. Xstatic XtCallbackProc IdentsCancelCallback(Widget widget, XtPointer data,
  889. X            XmPushButtonCallbackStruct *reason)
  890. X`7B
  891. X    XtRemoveWorkProc(idents_work_proc_id);
  892. X    idents_work_proc_id = (XtWorkProcId) 0;
  893. X`7D
  894. X
  895. X
  896. X/*
  897. X *  Stop find() when 'find progress' WorkingDialog widget is cancelled
  898. X */
  899. X
  900. Xstatic XtCallbackProc FindCancelCallback(Widget widget, XtPointer data,
  901. X            XmPushButtonCallbackStruct *reason)
  902. X`7B
  903. X    XtRemoveWorkProc(find_work_proc_id);
  904. X    find_work_proc_id = (XtWorkProcId) 0;
  905. X    if (progress_id) `7B
  906. X        XtRemoveTimeOut(progress_id);        /* cancel pending timeout */
  907. X        progress_id = (XtIntervalId) 0;
  908. X    `7D
  909. X
  910. X    if (!found_ptr->next) `7B        /* nothing left on found list? */
  911. X        XtSetSensitive(button_array`5Bfind_button`5D, OFF);
  912. X        XtSetSensitive(button_array`5Bfind_menu`5D, OFF);
  913. X    `7D
  914. X`7D
  915. X
  916. X
  917. X/*
  918. X *  Pop up (or remove) the access dialog box
  919. X *  Called by 'Access' menu item
  920. X */
  921. X
  922. Xstatic XtCallbackProc Access(Widget widget, XtPointer data,
  923. X                XmToggleButtonCallbackStruct *reason)
  924. X`7B
  925. X    Cardinal wi, ac;
  926. X    Arg arglist`5B2`5D;
  927. X
  928. X    if (!access_box) `7B
  929. X        if ((MrmFetchWidget(Hierarchy, "access_box", toplevel,
  930. X             &access_box, &class)) != MrmSUCCESS)
  931. X            XtAppError(context, "Error Fetching Access main widget");
  932. X        /* adjust drawing area using hourSize resource */
  933. X        for (wi = UAI$_NETWORK_ACCESS_P; wi <= UAI$_REMOTE_ACCESS_S; wi++) `
  934. V7B
  935. X            ac = 0;
  936. X            XtSetArg(arglist`5Bac`5D, XmNwidth, resource_data.hour_size * 24
  937. V); ac++;  `20
  938. X            if (widget_array`5Bwi`5D)
  939. X                XtSetValues(widget_array`5Bwi`5D, arglist, ac);
  940. X        `7D
  941. X    `7D
  942. X    if (XtIsManaged(access_box)) `7B
  943. X        XtUnmanageChild(access_box);
  944. X        XmToggleButtonSetState(button_array`5Baccess_menu`5D, OFF, NO);
  945. X    `7D
  946. X    else `7B
  947. X        XtManageChild(access_box);
  948. X        XmToggleButtonSetState(button_array`5Baccess_menu`5D, ON, NO);
  949. X        update_prime();       /* may not have existed */
  950. X        set_handlers();       /* set window event handlers */
  951. X    `7D
  952. X`7D
  953. X
  954. X
  955. X/*
  956. X *  Pop up (or remove) the privs dialog box
  957. X *  Called by 'Privs' menu item
  958. X */
  959. X
  960. Xstatic XtCallbackProc Privs(Widget widget, XtPointer data,
  961. X                XmToggleButtonCallbackStruct *reason)
  962. X`7B
  963. X    if (!privs_box)
  964. X        if ((MrmFetchWidget(Hierarchy, "privs_box", toplevel,
  965. X             &privs_box, &class)) != MrmSUCCESS)
  966. X            XtAppError(context, "Error Fetching Privs main widget");
  967. X    if (XtIsManaged(privs_box)) `7B
  968. X        XtUnmanageChild(privs_box);
  969. X        XmToggleButtonSetState(button_array`5Bprivs_menu`5D, OFF, NO);
  970. X    `7D
  971. X    else `7B
  972. X        XtManageChild(privs_box);
  973. X        XmToggleButtonSetState(button_array`5Bprivs_menu`5D, ON, NO);
  974. X        update_privs();        /* may not have existed */
  975. X    `7D
  976. X`7D
  977. X
  978. X
  979. X/*
  980. X *  Activation callback on Select menu item
  981. X *  also called by select_key()
  982. X *  widget, reason not referenced
  983. X */
  984. X
  985. Xstatic XtCallbackProc Select(Widget widget, int *data,
  986. X                XmPushButtonCallbackStruct *reason)
  987. X`7B
  988. X    Cardinal ind, ac;
  989. X    Arg arglist`5B10`5D;
  990. X    ident *ptr, *tptr;
  991. X    char str`5B80`5D;
  992. X    XmString xmstr;
  993. X
  994. X    if (found_list.next `7C`7C *data < 100) `7B  /* skip if 100 and nothing
  995. V on list */
  996. X        XtSetSensitive(button_array`5Bfind_button`5D, ON);  /* 'find' button
  997. V is now active */
  998. X        XtSetSensitive(button_array`5Bfind_menu`5D, ON);    /* 'find' menu i
  999. Vtem is now active */
  1000. X    `7D
  1001. X    if (*data == 100) `7B  /* 100 means re-enable found_list */
  1002. X        found_ptr = &found_list;
  1003. X        return;
  1004. X    `7D
  1005. X
  1006. X    sprintf(str, "Reset %s search", select_data`5B*data`5D.name);
  1007. X    xmstr = XmStringCreateSimple(str);
  1008. X    ac = 0;
  1009. X    XtSetArg(arglist`5Bac`5D, XmNlabelString, xmstr); ac++;
  1010. X    XtSetArg(arglist`5Bac`5D, XmNsensitive, TRUE); ac++;
  1011. X    XtSetValues(button_array`5Brestart_button`5D, arglist, ac);
  1012. X    XmStringFree(xmstr);
  1013. X
  1014. X    for (ptr = found_list.next; ptr;) `7B /* free old found list */
  1015. X        XtFree(ptr->name);
  1016. X        tptr = ptr;
  1017. X        ptr = ptr->next;
  1018. X        XtFree(tptr);
  1019. X    `7D
  1020. X    select_index = *data;       /* which field to match */
  1021. X    if (select_string)
  1022. X        XtFree(select_string);  /* free memory used by old string */
  1023. X    switch (select_data`5B*data`5D.type) `7B
  1024. X    case DWP_ALPHA:  /* username, account */
  1025. X    case DWP_LALPHA: /* other text fields */
  1026. X    case DWP_UIC:    /* use the text of UIC */
  1027. X        /* we could parse_dev(), parse_dir(), etc. here to ensure match */
  1028. X        select_string = XtNewString(unpad(uafdata`5Bselect_data`5B*data`5D.c
  1029. Vode`5D.sdata));
  1030. X        break;
  1031. X    case DWP_DATE:  /* pwdlifetime, expiration; text string or 64 bit date *
  1032. V/
  1033. X        if (uafdata`5Bselect_data`5B*data`5D.code`5D.changed)  /* text was e
  1034. Vntered */
  1035. X            if (!parse_date(select_data`5B*data`5D.code))  /* convert text t
  1036. Vo binary */
  1037. X                DWPerror("Select","Illegal date format", 0);
  1038. X        select_string = XtMalloc(select_data`5B*data`5D.size);
  1039. X        memcpy(select_string, uafdata`5Bselect_data`5B*data`5D.code`5D.sdata
  1040. V,
  1041. X               select_data`5B*data`5D.size);
  1042. X        break;
  1043. X    default:
  1044. X        select_string = XtNewString("");  /* so find_work_proc won't blow up
  1045. V */
  1046. X    `7D
  1047. X    select_ptr = found_add = NULL;  /* restart find from the beginning */
  1048. X    found_list.next = NULL;
  1049. X    found_ptr = &found_list;
  1050. X    if (find_work_proc_id)  /* is there one going on now? */
  1051. X        XtRemoveWorkProc(find_work_proc_id);  /* stop it */
  1052. X    find_work_proc_id = XtAppAddWorkProc(context, find_work_proc, NULL);
  1053. X    /* note: to be run first, read_identifiers must be called after AppAddWo
  1054. VrkProc */
  1055. X    read_identifiers(FALSE);        /* set up ident_list if necessary */
  1056. X`7D
  1057. X
  1058. X
  1059. X/*
  1060. X *  Creation callback;  save the widget using the UAI code as the index
  1061. X */
  1062. X
  1063. Xstatic XtCallbackProc WidgetCreated(Widget widget, XtPointer data,
  1064. X                XmAnyCallbackStruct *reason)
  1065. X`7B
  1066. X    widget_array`5B*data`5D = widget;
  1067. X`7D
  1068. X
  1069. X
  1070. X/*
  1071. X *  Creation callback;  save the save menu button widget in button_array
  1072. X */
  1073. X
  1074. Xstatic XtCallbackProc ButtonCreated(Widget widget, XtPointer data,
  1075. X                XmAnyCallbackStruct *reason)
  1076. X`7B
  1077. X    button_array`5B*data`5D = widget;
  1078. X`7D
  1079. X
  1080. X
  1081. X/*
  1082. X *  Called whenever a key is pressed in a text widget
  1083. X */
  1084. X
  1085. Xstatic XtCallbackProc WidgetChanged(Widget widget, XtPointer data,
  1086. X                XmTextVerifyCallbackStruct *reason)
  1087. X`7B
  1088. X    String str;
  1089. X    Cardinal pos;
  1090. X
  1091. X    if (setting_widgets) return;
  1092. X    pos = XmTextGetInsertionPosition(widget);
  1093. X    str = XmTextGetString(widget);
  1094. X    uafdata`5B*data`5D.changed = TRUE;    /* element has changed */
  1095. X    if (*data != UAI$_OWNER)
  1096. X            uppercase(str);
  1097. X    strcpy(uafdata`5B*data`5D.sdata, str);
  1098. X    setting_widgets = TRUE;        /* Don't allow recursion */
  1099. X    XmTextSetString(widget, str);
  1100. X    XmTextSetInsertionPosition(widget, pos);
  1101. X    setting_widgets = FALSE;
  1102. X    XtFree(str);
  1103. X`7D
  1104. X
  1105. X
  1106. X/*
  1107. X *  Called when flag toggle button is created
  1108. X */
  1109. X
  1110. Xstatic XtCallbackProc FlagsCreated(Widget widget, XtPointer data,
  1111. X            XmAnyCallbackStruct *reason)
  1112. X`7B
  1113. X    flags_array`5B*data`5D = widget;
  1114. X`7D
  1115. X
  1116. X
  1117. X/*
  1118. X *  Called whenever a flag toggle button is pressed
  1119. X */
  1120. X
  1121. Xstatic XtCallbackProc FlagsChanged(Widget widget, XtPointer data,
  1122. X            XmAnyCallbackStruct *reason)
  1123. X`7B
  1124. X    if (setting_flags) return;
  1125. X    uafdata`5BUAI$_FLAGS`5D.changed = TRUE;        /* element has changed */
  1126. X    uafdata`5BUAI$_FLAGS`5D.idata `5E= 1 << *data;    /* toggle flag bit */
  1127. X`7D
  1128. X
  1129. X
  1130. X/*
  1131. X *  Called when a primary day toggle button is created
  1132. X */
  1133. X
  1134. Xstatic XtCallbackProc PrimeCreated(Widget widget, XtPointer data,
  1135. X            XmAnyCallbackStruct *reason)
  1136. X`7B
  1137. X    prime_array`5B*data`5D = widget;
  1138. X`7D
  1139. X
  1140. X
  1141. X/*
  1142. X *  Called whenever a prime day toggle button is pressed
  1143. X */
  1144. X
  1145. Xstatic XtCallbackProc PrimeChanged(Widget widget, XtPointer data,
  1146. X            XmAnyCallbackStruct *reason)
  1147. X`7B
  1148. X    if (setting_prime) return;
  1149. X    uafdata`5BUAI$_PRIMEDAYS`5D.changed = TRUE;        /* element has change
  1150. Vd */
  1151. X    uafdata`5BUAI$_PRIMEDAYS`5D.idata `5E= 1 << *data;    /* toggle bit in p
  1152. Vrimedays */
  1153. X`7D
  1154. X
  1155. X
  1156. X/*
  1157. X *  Called when a privs toggle button is created
  1158. X */
  1159. X
  1160. Xstatic XtCallbackProc PrivsCreated(Widget widget, XtPointer data,
  1161. X            XmAnyCallbackStruct *reason)
  1162. X`7B
  1163. X    privs_array`5B*data`5D = widget;
  1164. X`7D
  1165. X
  1166. X
  1167. X/*
  1168. X *  Called whenever a privs toggle button is pressed
  1169. X */
  1170. X
  1171. Xstatic XtCallbackProc PrivsChanged(Widget widget, XtPointer data,
  1172. X            XmAnyCallbackStruct *reason)
  1173. X`7B
  1174. X    if (setting_privs) return;
  1175. X    if (*data < PRIVS_BIAS) `7B
  1176. X        uafdata`5BUAI$_PRIV`5D.sdata`5B*data >> 3`5D `5E= 1 << (*data & 7);
  1177. X        uafdata`5BUAI$_PRIV`5D.changed = TRUE;    /* element has changed */
  1178. X        `7D
  1179. X    else `7B
  1180. X        uafdata`5BUAI$_DEF_PRIV`5D.sdata`5B(*data - PRIVS_BIAS) >> 3`5D `5E=
  1181. X            1 << (*data - PRIVS_BIAS & 7);
  1182. X        uafdata`5BUAI$_DEF_PRIV`5D.changed = TRUE;
  1183. X    `7D
  1184. X`7D
  1185. X
  1186. X
  1187. X/*
  1188. X *  Read selection box widget to get account name
  1189. X *  Create new UIC
  1190. X */
  1191. X
  1192. Xstatic XtCallbackProc AccountChanged(Widget widget, XtPointer data,
  1193. X            XmSelectionBoxCallbackStruct *reason)
  1194. X`7B
  1195. X    String str;
  1196. X    Cardinal ind;
  1197. X
  1198. X    if (reason->reason == XmCR_CANCEL) `7B
  1199. X        XmTextSetString(widget_array`5BUAI$_ACCOUNT`5D, "");
  1200. X        uafdata`5BUAI$_ACCOUNT`5D.changed = TRUE;
  1201. X        strcpy(uafdata`5BUAI$_ACCOUNT`5D.sdata, "");
  1202. X        return;
  1203. X    `7D
  1204. X
  1205. X    XmStringGetLtoR(reason->value, XmSTRING_DEFAULT_CHARSET, &str);
  1206. X    XmTextSetString(widget_array`5BUAI$_ACCOUNT`5D, str);
  1207. X    uafdata`5BUAI$_ACCOUNT`5D.changed = TRUE;
  1208. X    strcpy(uafdata`5BUAI$_ACCOUNT`5D.sdata, str);
  1209. X    uppercase(uafdata`5BUAI$_ACCOUNT`5D.sdata);
  1210. X    XtFree(str);
  1211. X    strcpy(uafdata`5BUAI$_UIC`5D.sdata, "`5B0,0`5D");    /* force UIC recalc
  1212. V */
  1213. X    calc_uic();
  1214. X    trans_uic(uafdata`5BUAI$_UIC`5D.idata);
  1215. X`7D
  1216. X
  1217. X
  1218. X/*
  1219. X *  Called by 'Read Identifiers' menu item
  1220. X */
  1221. X
  1222. Xstatic XtCallbackProc ReadIdentifiers(Widget widget, XtPointer data,
  1223. X            XmAnyCallbackStruct *reason)
  1224. X`7B
  1225. X    read_identifiers(TRUE);
  1226. X`7D
  1227. X
  1228. X
  1229. X/*
  1230. X *  Pop up accounts selection box widget
  1231. X *  Called by 'Accounts' menu item
  1232. X */
  1233. X
  1234. Xstatic XtCallbackProc Accounts(Widget widget, XtPointer data,
  1235. X            XmAnyCallbackStruct *reason)
  1236. X`7B
  1237. X    Cardinal ac;
  1238. X    Arg arglist`5B5`5D;
  1239. X    XmString xmstr;
  1240. X
  1241. X    /* make accounts_box */
  1242. X    /* this could be fetched from a UID file, but it's easier here */
  1243. X    if (!accounts_box) `7B
  1244. X        ac = 0;
  1245. X        xmstr = XmStringCreateSimple("DWProfile: Accounts");
  1246. X        XtSetArg(arglist`5Bac`5D, XmNdialogTitle, xmstr); ac++;
  1247. X`09XtSetArg(arglist`5Bac`5D, XmNdefaultPosition, FALSE); ac++;
  1248. X        accounts_box = XmCreateSelectionDialog(toplevel, "accounts_box", arg
  1249. Vlist, ac);
  1250. X        XmStringFree(xmstr);
  1251. X        XtAddCallback(accounts_box, XmNapplyCallback, AccountChanged, NULL);
  1252. X        XtAddCallback(accounts_box, XmNhelpCallback, Help, "menus windows ac
  1253. Vcounts");
  1254. X        XtUnmanageChild(XmSelectionBoxGetChild(accounts_box, XmDIALOG_OK_BUT
  1255. VTON));
  1256. X        XtUnmanageChild(XmSelectionBoxGetChild(accounts_box, XmDIALOG_CANCEL
  1257. V_BUTTON));
  1258. X    `7D
  1259. X    if (XtIsManaged(accounts_box)) `7B
  1260. X        XtUnmanageChild(accounts_box);
  1261. X        XmToggleButtonSetState(button_array`5Baccounts_menu`5D, OFF, NO);
  1262. X        return;
  1263. X    `7D
  1264. X    XtManageChild(accounts_box);
  1265. X    XmToggleButtonSetState(button_array`5Baccounts_menu`5D, ON, NO);
  1266. X    if (ident_list)
  1267. X        build_accounts();  /* build list from idents */
  1268. X    else
  1269. X        read_identifiers(FALSE); /* get idents, build list when done */
  1270. X`7D
  1271. X
  1272. X
  1273. X/*
  1274. X *  Pop up (or remove) the idents dialog box
  1275. X *  Called by 'Idents' menu item
  1276. X */
  1277. X
  1278. Xstatic XtCallbackProc Idents(Widget widget, XtPointer data,
  1279. X                XmAnyCallbackStruct *reason)
  1280. X`7B
  1281. X    if (!idents_box)
  1282. X        if ((MrmFetchWidget(Hierarchy, "idents_box", toplevel,
  1283. X             &idents_box, &class)) != MrmSUCCESS)
  1284. X            XtAppError(context, "Error Fetching Idents main widget");
  1285. X    if (XtIsManaged(idents_box)) `7B
  1286. X        XtUnmanageChild(idents_box);
  1287. X        XmToggleButtonSetState(button_array`5Bidents_menu`5D, OFF, NO);
  1288. X        return;
  1289. X    `7D
  1290. X    XtManageChild(idents_box);
  1291. X    XmToggleButtonSetState(button_array`5Bidents_menu`5D, ON, NO);
  1292. X    if (ident_list)
  1293. X        update_held();  /* build list from idents */
  1294. X    else
  1295. X        read_identifiers(FALSE);  /* get idents, build list when done */
  1296. X`7D
  1297. X
  1298. X
  1299. X/*
  1300. X *  Add (or remove) the identifier for the user
  1301. X *  Called by selecting identifier from list box
  1302. X */
  1303. X
  1304. Xstatic XtCallbackProc ListSelect(Widget widget, XtPointer data,
  1305. X                XmListCallbackStruct *list)
  1306. X`7B
  1307. X    Cardinal count, ind;
  1308. X    ident *ptr;
  1309. X    held_ident *hptr, *prev_hptr, *tmp_hptr;
  1310. X    String str;
  1311. X
  1312. X    switch(*data) `7B
  1313. X    case k_widget_all_list:
  1314. X        XmStringGetLtoR(list->item, XmSTRING_DEFAULT_CHARSET, &str);
  1315. X        /* find the identifier that matches the selected item */
  1316. X        for (ptr = ident_list; ptr; ptr = ptr->next)
  1317. X            if (!strcmp(ptr->name, str)) break;
  1318. X        XtFree(str);
  1319. X        for (hptr = held_list, prev_hptr = NULL; hptr; prev_hptr = hptr, hpt
  1320. Vr = hptr->next) /* find deleted id or end */
  1321. X            if (hptr->identifier == ptr->identifier) break;
  1322. X        if (!hptr) `7B   /* not in held list, make new node */
  1323. X            hptr = XtNew(held_ident);
  1324. X            hptr->name = XtNewString(ptr->name);
  1325. X            hptr->identifier = NULL;
  1326. X            hptr->next = NULL;
  1327. X            if (prev_hptr)
  1328. X                prev_hptr->next = hptr;  /* point prev node to new node */
  1329. X            else
  1330. X                held_list = hptr;        /* or start list with first new nod
  1331. Ve */
  1332. X        `7D
  1333. X        if (!hptr->identifier) `7B
  1334. X            hptr->status = add_ident;    /* not found */
  1335. X            hptr->identifier = ptr->identifier;
  1336. X        `7D
  1337. X        else
  1338. X            hptr->status = original; /* orig ident deleted then added back *
  1339. V/
  1340. X        break;
  1341. X    case k_widget_held_list:
  1342. X        count = 0;
  1343. X        for (hptr = held_list, prev_hptr = NULL; hptr;) `7B
  1344. X            tmp_hptr = NULL;
  1345. X            if (hptr->status == original `7C`7C
  1346. X                hptr->status == add_ident) count++;
  1347. X            if (count == list->item_position) `7B   /* is this the list item
  1348. V selected ? */
  1349. X                if (hptr->status == add_ident) `7B  /* if this is a pending
  1350. V add */
  1351. X                    if (prev_hptr)                /* remove it from held_lis
  1352. Vt */
  1353. X                        prev_hptr->next = hptr->next;
  1354. X                    else
  1355. X                        held_list = hptr->next;
  1356. X                    tmp_hptr = hptr;              /* and flag it for delete
  1357. V */
  1358. X                `7D
  1359. X                hptr->status = del_orig; /* original ident marked for remova
  1360. Vl */
  1361. X                break;
  1362. X            `7D
  1363. X            prev_hptr = hptr;
  1364. X            hptr = hptr->next;
  1365. X            if (tmp_hptr)
  1366. X                XtFree(tmp_hptr);
  1367. X        `7D
  1368. X        break;
  1369. X    `7D
  1370. X    update_held();
  1371. X`7D
  1372. X
  1373. X`20
  1374. X/*
  1375. X *  Activation callback on a help menu or help callback
  1376. X */
  1377. X
  1378. Xstatic XtCallbackProc Help(Widget widget, String data,
  1379. X                XmPushButtonCallbackStruct *reason)
  1380. X`7B
  1381. X
  1382. X    Cardinal ac;
  1383. X    Arg arglist`5B10`5D;
  1384. X    XmString appname, glossarytopic, overviewtopic, libspec, topic;
  1385. X    static Widget help_box = NULL;
  1386. X    Widget temp_help_box;
  1387. X
  1388. X    if (!strcmp(data, "context")) `7B
  1389. X        /* context sensitive help mode, we'll get back here via helpcallback
  1390. V */
  1391. X        DXmHelpOnContext(toplevel, FALSE);`09
  1392. X        return;
  1393. X    `7D
  1394. X
  1395. X    topic = XmStringCreateSimple(data);
  1396. X
  1397. X    if (!help_box `7C`7C XtIsManaged(help_box)) `7B
  1398. X        /* We're going to create a help widget */
  1399. X        ac = 0;
  1400. X        appname = XmStringCreateSimple("DWProfile");
  1401. X        overviewtopic = XmStringCreateSimple("overview");
  1402. X        libspec = XmStringCreateSimple(HELP_LIBRARY);
  1403. X        XtSetArg(arglist`5Bac`5D, DXmNapplicationName, appname); ac++;
  1404. X        XtSetArg(arglist`5Bac`5D, DXmNoverviewTopic, overviewtopic); ac++;
  1405. X        XtSetArg(arglist`5Bac`5D, DXmNlibrarySpec, libspec); ac++;
  1406. X    `7D
  1407. X
  1408. X    if (!help_box) `7B  /* create the help box */
  1409. X        help_box = DXmCreateHelpDialog (toplevel, "help_box", arglist, ac);
  1410. X        XmStringFree(appname);
  1411. X        XmStringFree(overviewtopic);
  1412. X        XmStringFree(libspec);
  1413. X    `7D
  1414. X
  1415. +-+-+-+-+-+-+-+-  END  OF PART 3 +-+-+-+-+-+-+-+-
  1416. -- 
  1417. Bruce Tanner        (310) 860-2451 x 596    Tanner@Cerritos.EDU
  1418. Cerritos College    Norwalk, CA             DoD #0161  NOMAD #007
  1419.