![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to calls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / uips / sd|
Return to calls.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / uips / sd |
1.1 root 1: /* calls.c - */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/others/quipu/uips/sd/RCS/calls.c,v 7.2 90/07/27 08:45:41 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/others/quipu/uips/sd/RCS/calls.c,v 7.2 90/07/27 08:45:41 mrose Exp $
9: */
10:
11: /*
12: * $Log: calls.c,v $
13: * Revision 7.2 90/07/27 08:45:41 mrose
14: * update
15: *
16: * Revision 7.1 90/07/09 14:41:49 mrose
17: * sync
18: *
19: * Revision 7.0 90/06/12 13:14:03 mrose
20: * *** empty log message ***
21: *
22: * Revision 1.6 90/04/26 10:36:16 emsrdsm
23: * *** empty log message ***
24: *
25: * Revision 1.5 90/04/25 15:07:22 emsrdsm
26: * i) lint'ed
27: *
28: * Revision 1.4 90/04/20 17:57:33 emsrdsm
29: * i) no more freeing
30: *
31: * Revision 1.3 90/04/18 18:26:06 emsrdsm
32: * fixed i) does not move to leaves
33: * ii) added default mechanism described using "typeDefaults" file.
34: * iii) added 'sorting' to attribute display
35: *
36: * Revision 1.2 90/03/15 16:29:40 emsrdsm
37: * fixes i) Prints messages correctly on exit.
38: * ii) Added rfc822 to greybook mailbox conversion
39: * iii) Removed bug that caused crash if 'local_dit' undefined
40: *
41: * Revision 1.1 90/03/09 17:40:20 emsrdsm
42: * Initial revision
43: *
44: * Revision 1.1 90/03/09 13:36:22 emsrdsm
45: * Initial revision
46: *
47: */
48:
49: #include "manifest.h"
50: #include "quipu/util.h"
51: #include "quipu/common.h"
52: #include "quipu/entry.h"
53: #include "usr.dirent.h"
54: #include "tailor.h"
55: #include "sequence.h"
56: #include "filt.h"
57: #include "y.tab.h"
58: #include "symtab.h"
59:
60: #define RESBUF 10000
61:
62: struct attrcomp * sort_attrs();
63: static dn2str ();
64:
65: typedef enum {rfc822, greybook} mailtype;
66: mailtype mailformat = rfc822;
67:
68: int scrollize;
69: PS opt;
70: Attr_Sequence read_types = 0, read_types2 = 0, oclass = 0;
71:
72: D_seq dnseq, textseq, back_seq;
73: table_entry symtab = 0;
74:
75: int current_entry, entry_number, display_entry;
76: int back_buf_num;
77:
78: int dn_print (), rdn_print(), as_print(), avs_comp_print();
79:
80: char bound = FALSE; /* indication of wether bound */
81: char * TidyString();
82:
83: /* hack to get isode/curses compatability */
84: #define WINDOW char
85:
86: #include "widget.h"
87: #include "wdgtdefs.h"
88:
89: extern text_height;
90: int text_state;
91:
92: #define DN_LIST 0
93: #define TEXT 1
94: #define BACK_LIST 3
95:
96: /* These are common operation variables */
97: #define STRINGLEN 1000
98: #define SMALLSTRING 255
99: #define MAXTYPES 255
100:
101: char goto_path[STRINGLEN]; /* Used by the 'G:goto' command*/
102: char base_path[STRINGLEN]; /* Used by all DS operations */
103: char friendly_base_path[STRINGLEN];
104: char friendly_name[STRINGLEN];
105: char namestr[STRINGLEN];
106: char cache [STRINGLEN];
107: char bindpass [STRINGLEN];
108: char srchvalue[STRINGLEN]; /* Used by search */
109: char svalue [STRINGLEN];
110: char mvalue [STRINGLEN];
111:
112: unsigned int curr_filt = 0;
113: unsigned int filt_num = 0;
114: unsigned int typeindx = 0;
115: filt_struct *filt_arr[MAXTYPES];
116: char *filtvalue[MAXTYPES];
117: static char *filttype[MAXTYPES];
118:
119: int default_num;
120: int *av_typeindx;
121: int *available_types[MAXTYPES];
122: char *levels[MAXTYPES];
123: int defaults[MAXTYPES];
124:
125: #ifndef NO_STATS
126: extern LLog *log_stat;
127: #endif
128:
129: /* These are used as the data for the binding connection */
130: char passwd[STRINGLEN];
131: extern char currentpath[];
132: extern char * myname;
133:
134: extern int sizelimit;
135: extern char *local_dit;
136: DN user_name;
137:
138: char * addobj = NULLCP;
139:
140: Filter search_filter;
141:
142: FILE *file;
143: char *file_names[MAXTYPES];
144:
145: char *get_strioid(ptr)
146: register char *ptr;
147: {
148: register char *end_ptr;
149:
150: while(*ptr == '"') ptr++;
151: while(*ptr != '"') ptr++;
152:
153: while(*ptr > '9' || *ptr < '0') ptr++;
154:
155: end_ptr = ptr;
156: while(*end_ptr != '\n') end_ptr++;
157:
158: *end_ptr = '\0';
159: return ptr;
160: }
161:
162:
163: user_tailor ()
164: {
165: char *part1;
166: char *part2;
167: char *getenv ();
168: char *ptr = "/.quipurc";
169: char *config_dir = "/.duaconfig/";
170: char *isode_config_dir = "sd/duaconfig/";
171: char *type_dir = "filterTypes/";
172: char *read_File = "readTypes";
173: char *type_defaults = "typeDefaults";
174:
175: char Dish_Home[BUFSIZ];
176: char read_Home[BUFSIZ];
177: char type_Home[BUFSIZ];
178: char type_defaults_Home[BUFSIZ];
179:
180: char stroid_buf[BUFSIZ];
181:
182: DIR *dir;
183:
184: struct dirent *dir_ent;
185:
186: char Read_in_Stuff[STRINGLEN];
187: char *p,
188: *TidyString(),
189: *SkipSpace(),
190: *end;
191:
192: int count, n, num;
193: int tempints[MAXTYPES];
194:
195: #ifndef NO_STATS
196: ll_hdinit (log_stat,"sd");
197: #endif
198:
199: if ((opt = ps_alloc (std_open)) == NULLPS)
200: fatal (-1,"ps_alloc failed");
201: if (std_setup (opt,stdout) == NOTOK)
202: fatal (-1,"std_setup failed");
203:
204: namestr[0] = '\0';
205: *passwd = '\0';
206: cache[0] = '\0';
207: currentpath[0] = '\0';
208:
209: (void) strcpy (Dish_Home, getenv ("HOME"));
210: (void) strcpy(read_Home, Dish_Home);
211: (void) strcpy(type_Home, Dish_Home);
212: (void) strcpy(type_defaults_Home, Dish_Home);
213:
214: (void) strcat(Dish_Home, ptr);
215: (void) strcat(read_Home, config_dir);
216: (void) strcat(read_Home, read_File);
217: (void) strcat(type_Home, config_dir);
218: (void) strcat(type_Home, type_dir);
219: (void) strcat(type_defaults_Home, type_defaults);
220:
221: if (!(dir = opendir(type_Home))) {
222: (void) strcpy(type_Home, isodefile(isode_config_dir,0));
223: (void) strcat(type_Home, type_dir);
224: if(!(dir = opendir(type_Home))) {
225: quit("Can't find directory filterTypes.\n", 1);
226: }
227: }
228:
229: rewinddir(dir);
230: filt_num = 0;
231: while(dir_ent = readdir(dir)) {
232: if (!(strncmp(dir_ent->d_name, "Type_", 5))) {
233: file_names[filt_num] =
234: (char *) malloc(strlen(dir_ent->d_name) + strlen(type_Home) + 2);
235: (void) strcpy(file_names[filt_num], type_Home);
236: (void) strcat(file_names[filt_num], dir_ent->d_name);
237: filt_num++;
238: }
239: }
240: (void) closedir(dir);
241:
242: if ((file = fopen (Dish_Home, "r")) == 0);
243: else {
244: while (fgets (Read_in_Stuff, STRINGLEN, file) != 0) {
245: p = SkipSpace (Read_in_Stuff);
246: if (( *p == '#') || (*p == '\0'))
247: continue; /* ignore comments and blanks */
248:
249: part1 = p;
250: if ((part2 = index (p,':')) == NULLCP)
251: continue; /* ignore it */
252:
253: *part2++ = '\0';
254: part2 = TidyString(part2);
255:
256: if (strcmp (part1, "username") == 0)
257: (void) strcpy (namestr, part2);
258: else if (strcmp (part1, "password") == 0)
259: (void) strcpy (passwd, part2);
260: else if (strcmp(part1, "prefergreybook") == 0)
261: mailformat = greybook;
262: else if (lexequ (part1, "dsap") == 0)
263: (void) tai_string (part2);
264: else if (lexequ (part1, "isode") == 0) {
265: char * split;
266: if ((split = index (part2,' ')) != NULLCP) {
267: *split++ = 0;
268: (void) isodesetvar (part2,split,0);
269: }
270: } else if (strcmp (part1, "service") == 0)
271: new_service (part2);
272: }
273: isodexport (NULLCP);
274: (void) fclose(file);
275: }
276:
277: if (!(file = fopen(read_Home, "r"))) {
278: (void) strcpy(read_Home, isodefile(isode_config_dir,0));
279: (void) strcat(read_Home, read_File);
280: if (!(file = fopen(read_Home, "r"))) {
281: quit("Can't find file readTypes.\n", 1);
282: }
283: }
284: load_oid_table("oidtable");
285:
286: while(fgets(Read_in_Stuff, STRINGLEN, file) != 0) {
287: (void) strcpy(stroid_buf, get_strioid(Read_in_Stuff));
288: if (*stroid_buf) {
289: if (!read_types)
290: read_types = as_comp_new(AttrT_new(stroid_buf), NULLAV, NULLACL_INFO);
291: else {
292: read_types2 = as_comp_new(AttrT_new(stroid_buf) ,NULLAV, NULLACL_INFO);
293: read_types = as_merge(read_types, read_types2);
294: }
295: }
296: }
297: (void) fclose(file);
298:
299: for (curr_filt = 0; curr_filt < filt_num; curr_filt++) {
300: if (!(file = fopen(file_names[curr_filt], "r"))) {
301: quit("Can't find filter template file\n", 1);
302: }
303: filtvalue[curr_filt] = (char *) malloc(STRINGLEN);
304: *filtvalue[curr_filt] = '\0';
305:
306: (void) yyparse();
307: (void) fclose(file);
308: }
309: filttype[curr_filt] = NULLCP;
310: for (count = 0; count < filt_num; count++)
311: free(file_names[count]);
312:
313: if (!(file = fopen(type_defaults_Home, "r"))) {
314: (void) strcpy(type_defaults_Home, isodefile(isode_config_dir,0));
315: (void) strcat(type_defaults_Home, type_defaults);
316: if (!(file = fopen(type_defaults_Home, "r"))) {
317: (void) strcpy(type_defaults_Home, "./sd/duaconfig/");
318: (void) strcat(type_defaults_Home, type_defaults);
319: if (!(file = fopen(type_defaults_Home, "r"))) {
320: (void) fprintf(stderr, "Can't open typeDefaults file\n");
321: quit(1);
322: }
323: }
324: }
325:
326: default_num = 0;
327: while (fgets (Read_in_Stuff, STRINGLEN, file) != 0) {
328: p = SkipSpace(Read_in_Stuff);
329: if (( *p == '#') || (*p == '\0'))
330: continue;
331:
332: part1 = p;
333: if ((part2 = index (p,':')) == NULLCP)
334: continue;
335:
336: end = part2 - 1;
337: while (isspace(*end)) end--;
338: *++end = '\0';
339:
340: *part2++ = '\0';
341:
342: while (isspace(*part2)) part2++;
343: end = part2;
344:
345: while (!isspace(*end) && *end != ',' && *end != ':') end++;
346:
347: count = 0;
348: while (*part2 != ':') {
349: n = 0;
350: while (n < filt_num && strncmp(filttype[n], part2,
351: (int) (end - part2))) n++;
352:
353: if (n == filt_num) {
354: (void) fprintf(stderr, "Parsing error in typeDefaults file!");
355: quit(1);
356: } else {
357: tempints[count] = n;
358: count++;
359: part2 = end;
360: while (!isalpha(*part2) && *part2 != ':' && part2 != '\0') part2++;
361:
362: if (*part2 == '\0') {
363: (void) fprintf(stderr, "Parsing error in typeDefaults file!");
364: quit(1);
365: }
366:
367: if (*part2 != ':') {
368: while (!isalpha(*part2)) part2++;
369: end = part2;
370: while (!isspace(*end) && *end != ',' &&
371: *end != ':' && *end != '\0') end++;
372: if (*end == '\0') {
373: (void) fprintf(stderr, "Parsing error in typeDefaults file!");
374: quit(1);
375: }
376: } else end = part2;
377: }
378: }
379: if (*end == ':') {
380: while(isspace(*++end));
381: p = end;
382: while(!isspace(*++end));
383: *end = '\0';
384:
385: n = 0;
386: while (n < filt_num && strcmp(filttype[n], p)) n++;
387:
388: if (n == filt_num) {
389: (void) fprintf(stderr, "Parsing error in typeDefaults file!");
390: quit(1);
391: } else {
392: num = 0;
393: while (num < count && n != tempints[num]) num++;
394: if (num == count) {
395: (void) fprintf(stderr, "Parsing error in typeDefaults file!");
396: quit(1);
397: }
398: }
399:
400: defaults[default_num] = n;
401:
402: levels[default_num] = malloc(strlen(part1) + 1);
403: (void) strcpy(levels[default_num], part1);
404: available_types[default_num] =
405: (int *) malloc(sizeof(int) * (count+1));
406:
407: for (n = 0; n < count; n++)
408: available_types[default_num][n] = tempints[n];
409:
410: available_types[default_num][n] = -1;
411: default_num++;
412: }
413: }
414: }
415:
416: make_type(name_val, filt)
417: char * name_val;
418: filt_struct * filt;
419: {
420: filttype[curr_filt] = (char *) malloc(strlen(name_val) + 1);
421: (void) strcpy(filttype[curr_filt], name_val);
422:
423: filt_arr[curr_filt] = filt;
424: }
425:
426: filt_struct *
427: make_item_filter(oid, match, value)
428: char *oid;
429: int match;
430: char *value;
431: {
432: register filt_struct * filt = (filt_struct *) malloc(sizeof(filt_struct));
433:
434: filt->flt_type = ITEM;
435: filt->next = 0;
436:
437: filt->fu_cont.item.fi_type = match;
438: filt->fu_cont.item.stroid = (char *) malloc(strlen(oid) + 1);
439: (void) strcpy(filt->fu_cont.item.stroid, oid);
440:
441: if (*value == '*') filt->fu_cont.item.name = (char *) 0;
442: else {
443: filt->fu_cont.item.name = (char *) malloc(strlen(value) + 1);
444: (void) strcpy(filt->fu_cont.item.name, value);
445: }
446: return filt;
447: }
448:
449: filt_struct *
450: link_filters(filt1, filt2)
451: filt_struct *filt1;
452: filt_struct *filt2;
453: {
454: filt1->next = filt2;
455: return filt1;
456: }
457:
458: filt_struct *
459: make_parent_filter(filt_type, filt1, filt2, filt3)
460: int filt_type;
461: filt_struct * filt1;
462: filt_struct * filt2;
463: filt_struct * filt3;
464: {
465: filt_struct * parent = (filt_struct *) malloc(sizeof(filt_struct));
466:
467: switch (filt_type) {
468:
469: case NOT:
470: parent->flt_type = NOT;
471: parent->fu_cont.sub_filt = filt1;
472: parent->next = 0;
473: break;
474:
475: case AND:
476: parent->flt_type = AND;
477: parent->fu_cont.sub_filt = filt1;
478: filt1->next = filt2;
479: filt2->next = filt3;
480: parent->next = 0;
481: break;
482:
483: default:
484: parent->flt_type = OR;
485: parent->fu_cont.sub_filt = filt1;
486: filt1->next = filt2;
487: filt2->next = filt3;
488: parent->next = 0;
489: break;
490: }
491:
492: return parent;
493: }
494:
495: /* These are the functions called by the main level of widgets */
496:
497: main_help()
498: {
499: cleartext();
500: killwidgets(mainwdgts);
501: setwidgets(dethelpwdgts,-1);
502: help_cncs();
503: }
504:
505: main_bind()
506: {
507: cleartext();
508: if (*passwd != 0)
509: (void) strcpy(bindpass,"******");
510: else
511: bindpass[0] = '\0';
512: }
513:
514: cnnct_quit ()
515: {
516: quit("Exiting sd.\n", 0);
517: }
518:
519: cnnct_bind()
520: {
521: struct ds_bind_arg bindarg;
522: struct ds_bind_arg bindresult;
523: struct ds_bind_error binderr;
524: extern char * dsa_address,
525: * myname;
526: extern char * tailfile;
527: FILE * fp;
528: char buf [BUFSIZ];
529:
530: /* set dsa_address */
531: dsa_address = NULLCP;
532: /* read tailor file to get address */
533: if( (fp = fopen(isodefile(tailfile,0), "r")) == (FILE *)NULL) {
534: tprint ("Cannot open tailor file %s\n",isodefile(tailfile,0));
535: return;
536: }
537: while(fgets(buf, sizeof(buf), fp) != NULLCP)
538: if ( (*buf != '#') && (*buf != '\n') )
539: (void) tai_string(buf);
540:
541: (void) fclose(fp);
542:
543: if (dsa_address == NULLCP)
544: dsa_address = myname;
545:
546: /* set password */
547: if (bindpass[0] != 0) {
548: if (strcmp (bindpass,"******") != 0)
549: (void) strcpy (passwd,bindpass);
550: } else
551: passwd[0] = 0;
552:
553: /* now bind */
554: bindarg.dba_version = DBA_VERSION_V1988;
555: if (passwd[0] == 0) {
556: bindarg.dba_passwd_len = 0;
557: bindarg.dba_passwd [0] = '\0';
558: } else {
559: bindarg.dba_passwd_len = strlen (passwd);
560: (void) strcpy (bindarg.dba_passwd,passwd);
561: }
562:
563: bindarg.dba_dn = (*namestr == 0? NULLDN: str2dn(namestr));
564:
565: if (ds_bind (&bindarg,&binderr,&bindresult) != DS_OK) {
566: if (binderr.dbe_type == DBE_TYPE_SECURITY)
567: quit("Bind security error - Check name and pasword.\n", 0);
568: else
569: quit("Bind service error - Can't contact DSA!\n", 1);
570: } else {
571: setdialogstr(getwidget(mainwdgts, '\0'), friendly_base_path, STRINGLEN);
572: setdialogstr(getwidget(mainwdgts, 's'), mvalue, STRINGLEN);
573: setdialogstr(getwidget(mainwdgts, '*'), srchvalue, 6);
574: settogglstrs(getwidget(mainwdgts, 't'), filttype, 0);
575: setwidgets (mainwdgts,-1);
576: user_name = bindarg.dba_dn;
577:
578: if(local_dit && *local_dit)
579: (void) strcpy(base_path, local_dit);
580: else
581: (void) strcpy(base_path, "The World");
582:
583: oclass = as_comp_new(AttrT_new("objectClass"), NULLAV, NULLACL_INFO);
584: make_friendly(friendly_base_path, base_path);
585: printdialog(getwidget(mainwdgts,'\0'));
586: set_default_type();
587:
588: (void) strcpy (buf, "TERM");
589:
590: #ifndef NO_STATS
591: LLOG (log_stat,LLOG_NOTICE,("bound ('%s' to '%s')",namestr,dsa_address));
592: #endif
593: #ifndef NO_STATS
594: LLOG (log_stat,LLOG_NOTICE,("sd called from a ('%s')", getenv(buf)));
595: #endif
596: }
597: display_entry = current_entry = 1;
598: entry_number = 0;
599: back_buf_num = 0;
600: textseq = back_seq = dnseq = NULLDS;
601: text_state = TEXT;
602: }
603:
604: rd_start()
605: {
606: struct ds_read_arg read_arg;
607: struct ds_read_result result;
608: struct DSError error;
609: Entry read_entry;
610:
611: cleartext();
612: if (*friendly_base_path == 'T') {
613: free_seq(textseq);
614: if (text_state == DN_LIST) free_seq(dnseq);
615: dnseq = textseq = NULLDS;
616: text_state = TEXT;
617: entry_number = 0;
618: return;
619: }
620:
621: xprint("Reading data on ");
622: xprint(friendly_base_path);
623: xprint(".\n");
624: tprint("Chugging along.....");
625:
626: if ( get_default_service (&read_arg.rda_common) != 0) {
627: xprint ("Default service error -> check your .quipurc\n");
628: return ;
629: }
630:
631: read_arg.rda_common.ca_servicecontrol.svc_options = 1;
632: read_arg.rda_eis.eis_allattributes = FALSE;
633: read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
634: read_arg.rda_eis.eis_select = read_types;
635:
636: read_arg.rda_object = (*friendly_base_path != 'T'? str2dn(base_path): NULLDN);
637: if ((read_entry =
638: local_find_entry (read_arg.rda_object, FALSE)) != NULLENTRY) {
639: read_entry->e_attributes = sort_attrs(read_entry->e_attributes);
640: read_print (as_print, (caddr_t) read_entry->e_attributes);
641: return;
642: }
643:
644: #ifndef NO_STATS
645: LLOG (log_stat,LLOG_NOTICE,("read +%s",base_path));
646: #endif
647:
648: if (ds_read (&read_arg,&error,&result) != DS_OK) {
649: /* deal with error */
650: cleartext();
651: xprint("Read error due to:\n");
652: quipu_error(&error);
653: } else {
654: /* use data */
655: if (result.rdr_entry.ent_attr == NULLATTR) {
656: free_seq(textseq);
657: if (text_state == DN_LIST) free_seq(dnseq);
658: dnseq = textseq = NULLDS;
659: entry_number = 0;
660: text_state = TEXT;
661: xprint("No attributes");
662: return;
663: }
664: xprint("Result of look up ...\n");
665: if (result.rdr_common.cr_aliasdereferenced)
666: xprint("Alias dereferenced)\n");
667:
668: result.rdr_entry.ent_attr = sort_attrs(result.rdr_entry.ent_attr);
669: cache_entry(&(result.rdr_entry), TRUE, TRUE);
670: read_print(as_print, (caddr_t) result.rdr_entry.ent_attr);
671: }
672: }
673:
674: back_start()
675: {
676: if (!back_buf_num) {
677: cleartext();
678: tprint("You haven't been anywhere yet!\n");
679: sleep(3);
680: scrollbar('\0');
681: return;
682: }
683:
684: if (text_state == DN_LIST) free_seq(dnseq);
685:
686: free_seq(textseq);
687: textseq = NULLDS;
688: dnseq = back_seq;
689: text_state = BACK_LIST;
690: entry_number = back_buf_num;
691: current_entry = display_entry = 1;
692: scrollbar('\0');
693: }
694:
695: widen()
696: {
697: register char *str, *sptr;
698: int count = 0;
699:
700: str = get_from_seq(count+1, back_seq);
701: while (count < back_buf_num && strcmp(str, base_path)){
702: count++;
703: str = get_from_seq(count+1, back_seq);
704: }
705: if (count == back_buf_num) {
706: add_seq(&back_seq, base_path);
707: back_buf_num++;
708: }
709:
710: str = base_path;
711: if (*str != 'T') {
712:
713: for (sptr = str; *sptr != '\0'; sptr++)
714: if (*sptr == '@') str = sptr;
715:
716: sptr = str;
717: typetoggled = 0;
718:
719: if (str != base_path) {
720: if (*--sptr == ' ')
721: str = sptr;
722: *str = '\0';
723: } else
724: (void) strcpy(base_path, "The World");
725:
726: make_friendly(friendly_base_path, base_path);
727: set_default_type();
728: printdialog(getwidget(mainwdgts, '\0'));
729: rd_start();
730: }
731: }
732:
733: set_default_type()
734: {
735: int count, lastindx;
736: WIDGET *wdgt, *vwdgt;
737: DN base_name;
738:
739: wdgt = getwidget(mainwdgts,'t');
740: vwdgt = getwidget(mainwdgts, 's');
741:
742: if (av_typeindx)
743: lastindx = wdgt->tindx;
744: else
745: lastindx = 0;
746:
747: if (*base_path != 'T') {
748: if (!typetoggled) {
749: base_name = str2dn(base_path);
750: while (base_name->dn_parent) base_name = base_name->dn_parent;
751: for (count = 0; count < default_num &&
752: strcmp(levels[count] ,base_name->dn_rdn->rdn_at->
753: oa_ot.ot_stroid);
754: count++);
755:
756: if (count < default_num) {
757: av_typeindx = available_types[count];
758: typeindx = defaults[count];
759: } else {
760: av_typeindx = available_types[0];
761: typeindx = defaults[0];
762: }
763: count = typeindx;
764:
765: if (count < filt_num) {
766: if (lastindx)
767: (void) strcpy(filtvalue[lastindx], vwdgt->dstr);
768: wdgt->tindx = count;
769: (void) strcpy(vwdgt->dstr, filtvalue[wdgt->tindx]);
770: }
771: }
772: } else {
773: for(count = 0; count < default_num && strcmp(levels[count], "@"); count++);
774: if (count < default_num) {
775: av_typeindx = available_types[count];
776: typeindx = defaults[count];
777: } else {
778: av_typeindx = available_types[0];
779: typeindx = defaults[0];
780: }
781: count = typeindx;
782: if (count < filt_num) {
783: if (lastindx)
784: (void) strcpy(filtvalue[lastindx], vwdgt->dstr);
785: wdgt->tindx = count;
786: (void) strcpy(vwdgt->dstr, filtvalue[wdgt->tindx]);
787: }
788: }
789:
790: make_friendly(friendly_base_path, base_path);
791: typetoggled = 0;
792: printtoggle(wdgt);
793: printdialog(vwdgt);
794: }
795:
796: /* These are the functions called by the list level widgets */
797:
798: list_start()
799: {
800: struct ds_search_arg search_arg;
801: struct ds_search_result result;
802: struct DSError error;
803:
804: cleartext();
805: xprint("OK, listing.\n");
806: tprint("Chugging along.....");
807:
808: if (get_default_service (&search_arg.sra_common) != 0) {
809: xprint ("Default service error -> check your .quipurc\n");
810: return ;
811: }
812:
813: search_arg.sra_common.ca_servicecontrol.svc_sizelimit = sizelimit;
814: search_arg.sra_common.ca_servicecontrol.svc_options = 1;
815: search_arg.sra_baseobject = (*base_path != 'T'?
816: str2dn (base_path):
817: NULLDN);
818: search_arg.sra_eis.eis_allattributes = FALSE;
819: search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
820: search_arg.sra_eis.eis_select = read_types;
821: search_arg.sra_subset = SRA_ONELEVEL;
822:
823: search_arg.sra_filter = filter_alloc();
824: search_arg.sra_filter->flt_type = FILTER_NOT;
825: search_arg.sra_filter->flt_next = NULLFILTER;
826: search_arg.sra_filter->flt_un.flt_un_filter = filter_alloc();
827: search_arg.sra_filter->flt_un.flt_un_filter->flt_type = FILTER_ITEM;
828: search_arg.sra_filter->flt_un.flt_un_filter->flt_next = NULLFILTER;
829: search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.fi_type
830: = FILTERITEM_EQUALITY;
831:
832: search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.fi_un.
833: fi_un_ava.ava_type = AttrT_new("2.5.4.0");
834:
835: search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.fi_un.
836: fi_un_ava.ava_value =
837: str2AttrV("dsa", search_arg.sra_filter->flt_un.flt_un_filter->
838: flt_un.flt_un_item.fi_un.fi_un_ava.ava_type->
839: oa_syntax);
840:
841: if (search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.
842: fi_un.fi_un_ava.ava_value == NULLAttrV) {
843: cleartext();
844: xprint("No can do. Sorry!");
845: } else if (ds_search (&search_arg,&error,&result) != DS_OK) {
846: /* deal with error */
847: free_seq(textseq);
848: if (text_state == DN_LIST) free_seq(dnseq);
849: dnseq = textseq = NULLDS;
850: text_state = TEXT;
851: entry_number = 0;
852: cleartext();
853: xprint("Search error due to:\n");
854: quipu_error(&error);
855: } else {
856: cleartext();
857: correlate_search_results (&result);
858: if (result.CSR_entries != NULLENTRYINFO) {
859: register EntryInfo *ptr;
860:
861: xprint ("Result of search ...\n");
862: if (result.CSR_common.cr_aliasdereferenced) {
863: xprint ("(Alias dereferenced - object is ");
864: quipu_print (dn_print, (caddr_t) result.CSR_object);
865: dn_free (result.CSR_object);
866: xprint (")\n");
867: }
868:
869: if (text_state == DN_LIST) free_seq(dnseq);
870: free_seq(textseq);
871: dnseq = textseq = NULLDS;
872: display_entry = current_entry = 1;
873: entry_number = 0;
874: text_state = DN_LIST;
875:
876: for (ptr = result.CSR_entries; ptr != NULLENTRYINFO;
877: ptr = ptr->ent_next) {
878: entry_number++;
879: dn2str ((caddr_t)ptr->ent_dn, goto_path);
880: add_seq (&dnseq, goto_path);
881: cache_entry (ptr,TRUE,TRUE);
882: }
883: scrollbar('\0');
884: } else if (result.CSR_limitproblem != LSR_TIMELIMITEXCEEDED) {
885: free_seq(textseq);
886: if (text_state == DN_LIST) free_seq(dnseq);
887: dnseq = textseq = NULLDS;
888: entry_number = 0;
889: text_state = TEXT;
890: xprint("Nothing found");
891: }
892:
893: if(result.CSR_limitproblem != LSR_NOLIMITPROBLEM) {
894: if(result.CSR_limitproblem == LSR_TIMELIMITEXCEEDED) {
895: free_seq(textseq);
896: if (text_state == DN_LIST) free_seq(dnseq);
897: dnseq = textseq = NULLDS;
898: entry_number = 0;
899: text_state = TEXT;
900: xprint("(Time limit exceeded)");
901: } else
902: xprint("(Size limit exceeded)");
903: }
904:
905: entryinfo_free(result.CSR_entries, 0);
906: }
907:
908: filter_free(search_arg.sra_filter);
909: }
910:
911: rdn2str(ptr,cptr)
912: caddr_t ptr;
913: char * cptr;
914: {
915: PS ps;
916: char buffer [RESBUF];
917:
918: if ((ps = ps_alloc(str_open)) == NULLPS) {
919: return ;
920: }
921: if (str_setup(ps, buffer, RESBUF, 1) == NOTOK) {
922: return ;
923: }
924: rdn_print(ps, (RDN) ptr, READOUT);
925:
926: ps_free(ps);
927: *ps->ps_ptr = 0;
928:
929: (void) strcpy(cptr, buffer);
930: }
931:
932:
933: /* search ... */
934:
935: Filter
936: make_filter(filt)
937: filt_struct *filt;
938: {
939: int type, count;
940: char *value;
941: Filter rfilt, sfilt = filter_alloc();
942:
943: if (!filt)
944: return (Filter) 0;
945:
946: switch(filt->flt_type) {
947:
948: case ITEM:
949: sfilt->flt_type = FILTER_ITEM;
950: sfilt->flt_next = make_filter(filt->next);
951:
952: if (strcmp(filt->fu_cont.item.stroid, "2.5.4.4"))
953: (void) strcpy(svalue, (filt->fu_cont.item.name?
954: filt->fu_cont.item.name:
955: mvalue));
956: else if (!filt->fu_cont.item.name) {
957: count = strlen(mvalue);
958: value = mvalue + count - 1;
959:
960: while(!isalpha(*value) && value > mvalue) value--;
961: while (!isspace(*value) && value > mvalue) value--;
962:
963: if (mvalue < value) (void) strcpy(svalue, ++value);
964: else (void) strcpy(svalue, mvalue);
965: } else (void) strcpy(svalue, filt->fu_cont.item.name);
966: type = filt->fu_cont.item.fi_type;
967:
968: switch(type) {
969: case APPROX:
970: case EQUAL:
971: sfilt->flt_un.flt_un_item.fi_un.fi_un_ava.ava_type =
972: AttrT_new(filt->fu_cont.item.stroid);
973:
974: if ((sfilt->flt_un.flt_un_item.fi_un.fi_un_ava.ava_value =
975: str2AttrV(svalue,
976: sfilt->flt_un.flt_un_item.fi_un.fi_un_ava.ava_type->
977: oa_syntax)) == NULL) {
978:
979: rfilt = sfilt->flt_next;
980: sfilt->flt_next = NULLFILTER;
981: filter_free(sfilt);
982: return rfilt;
983: }
984:
985: if (type == EQUAL)
986: sfilt->flt_un.flt_un_item.fi_type = FILTERITEM_EQUALITY;
987: else
988: sfilt->flt_un.flt_un_item.fi_type = FILTERITEM_APPROX;
989:
990: break;
991:
992: case SUBSTRING:
993: sfilt->flt_un.flt_un_item.fi_type = FILTERITEM_SUBSTRINGS;
994: sfilt->flt_un.flt_un_item.fi_un.fi_un_substrings.fi_sub_type =
995: AttrT_new(filt->fu_cont.item.stroid);
996:
997: sfilt->flt_un.flt_un_item.fi_un.fi_un_substrings.fi_sub_initial =
998: NULLAV;
999: sfilt->flt_un.flt_un_item.fi_un.fi_un_substrings.fi_sub_final =
1000: NULLAV;
1001: sfilt->flt_un.flt_un_item.fi_un.fi_un_substrings.fi_sub_any =
1002: avs_comp_new(str2AttrV(svalue,
1003: sfilt->flt_un.flt_un_item.fi_un.
1004: fi_un_substrings.fi_sub_type->
1005: oa_syntax));
1006: break;
1007:
1008: default:
1009: sfilt->flt_un.flt_un_item.fi_type = FILTERITEM_APPROX;
1010: break;
1011: }
1012: return sfilt;
1013: break;
1014:
1015: case AND:
1016: sfilt->flt_type = FILTER_AND;
1017: sfilt->flt_un.flt_un_filter = make_filter(filt->fu_cont.sub_filt);
1018: sfilt->flt_next = make_filter(filt->next);
1019: return sfilt;
1020: break;
1021:
1022: case OR:
1023: sfilt->flt_type = FILTER_OR;
1024: sfilt->flt_un.flt_un_filter = make_filter(filt->fu_cont.sub_filt);
1025: sfilt->flt_next = make_filter(filt->next);
1026: return sfilt;
1027: break;
1028:
1029: case NOT:
1030: sfilt->flt_type = FILTER_NOT;
1031: sfilt->flt_next = make_filter(filt->next);
1032: sfilt->flt_un.flt_un_filter = make_filter(filt->fu_cont.sub_filt);
1033: return sfilt;
1034: break;
1035:
1036: default:
1037: return NULLFILTER;
1038: }
1039: }
1040:
1041:
1042: srch_start()
1043: {
1044: struct ds_search_arg search_arg;
1045: struct ds_search_result result;
1046: struct DSError error;
1047: WIDGET *wdgt;
1048: char *str = base_path;
1049:
1050: if (*mvalue == '\0') {
1051: list_start();
1052: return;
1053: }
1054:
1055: cleartext();
1056: xprint("OK. Starting search.\n");
1057: tprint("Chugging along.....");
1058:
1059: wdgt = getwidget(mainwdgts,'t');
1060:
1061: if (get_default_service (&search_arg.sra_common) != 0) {
1062: xprint ("Default service error -> check your .quipurc\n");
1063: return ;
1064: }
1065:
1066: search_arg.sra_common.ca_servicecontrol.svc_options = 1;
1067: search_arg.sra_common.ca_servicecontrol.svc_sizelimit = sizelimit;
1068: search_arg.sra_baseobject = (*base_path != 'T'?
1069: str2dn (base_path):
1070: NULLDN);
1071: search_arg.sra_eis.eis_allattributes = FALSE;
1072: search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
1073: search_arg.sra_eis.eis_select = read_types;
1074:
1075: while (*str != '\0' && *str != '@') str++;
1076:
1077: search_arg.sra_subset = ((*base_path != 'T' && *str == '@')?
1078: SRA_WHOLESUBTREE:
1079: SRA_ONELEVEL);
1080: search_arg.sra_filter =
1081: make_filter(filt_arr[gettogglindx(wdgt)]);
1082:
1083: #ifndef NO_STATS
1084: LLOG (log_stat,LLOG_NOTICE,("search +%s, extent %d, val %s",base_path,search_arg.sra_subset,mvalue));
1085: #endif
1086:
1087: if(ds_search (&search_arg,&error,&result) != DS_OK) {
1088: /* deal with error */
1089: free_seq(textseq);
1090: if (text_state == DN_LIST) free_seq(dnseq);
1091: dnseq = textseq = NULLDS;
1092: entry_number = 0;
1093: text_state = TEXT;
1094: cleartext();
1095: xprint(" Search error due to:\n ");
1096: quipu_error(&error);
1097: } else {
1098: cleartext();
1099: correlate_search_results (&result);
1100:
1101: if (result.CSR_entries != NULLENTRYINFO) {
1102: register EntryInfo *ptr;
1103:
1104: if (result.CSR_common.cr_aliasdereferenced) {
1105: xprint (" (Alias dereferenced - object is ");
1106: quipu_print (dn_print, (caddr_t) result.CSR_object);
1107: dn_free (result.CSR_object);
1108: xprint (")\n");
1109: }
1110:
1111: if (text_state == DN_LIST) free_seq(dnseq);
1112: free_seq(textseq);
1113: dnseq = textseq = NULLDS;
1114: display_entry = current_entry = 1;
1115: entry_number = 0;
1116: text_state = DN_LIST;
1117:
1118: for (ptr = result.CSR_entries;
1119: ptr != NULLENTRYINFO; ptr = ptr->ent_next){
1120: entry_number++;
1121: dn2str ((caddr_t) ptr->ent_dn, goto_path);
1122: add_seq (&dnseq, goto_path);
1123: cache_entry (ptr,TRUE,TRUE);
1124: }
1125:
1126: if (entry_number != 1)
1127: scrollbar('\0');
1128: else {
1129: if (!isleaf(goto_path)) {
1130: get_listed_object('1', 0);
1131: } else {
1132: char temp[1024];
1133: (void) strcpy(temp, base_path);
1134: (void) strcpy(base_path, goto_path);
1135: rd_start();
1136: (void) strcpy(base_path, temp);
1137: }
1138: }
1139: } else if(result.CSR_limitproblem != LSR_TIMELIMITEXCEEDED) {
1140: free_seq(textseq);
1141: if (text_state == DN_LIST) free_seq(dnseq);
1142: dnseq = textseq = NULLDS;
1143: entry_number = 0;
1144: text_state = TEXT;
1145: xprint("Nothing found using current search parameters. Sorry!\n");
1146: }
1147:
1148: if(result.CSR_limitproblem != LSR_NOLIMITPROBLEM)
1149: if(result.CSR_limitproblem == LSR_TIMELIMITEXCEEDED) {
1150: free_seq(textseq);
1151: if (text_state == DN_LIST) free_seq(dnseq);
1152: dnseq = textseq = NULLDS;
1153: entry_number = 0;
1154: text_state = TEXT;
1155: xprint("(Time limit exceeded)");
1156: } else
1157: xprint("(Size limit exceeded)");
1158:
1159: entryinfo_free(result.CSR_entries, 0);
1160: }
1161:
1162: filter_free(search_arg.sra_filter);
1163: }
1164:
1165: static dn2str (ptr,cptr)
1166: caddr_t ptr;
1167: char * cptr;
1168: {
1169: PS ps;
1170: char buffer [RESBUF];
1171:
1172: if((ps = ps_alloc(str_open)) == NULLPS) return ;
1173:
1174: if(str_setup(ps, buffer, RESBUF, 1) == NOTOK) return ;
1175:
1176: dn_print(ps, (DN) ptr, EDBOUT);
1177: *ps->ps_ptr = 0;
1178:
1179: ps_free (ps);
1180:
1181: (void) strcpy(cptr, buffer);
1182: }
1183:
1184:
1185: read_print(func,ptr)
1186: int (*func) ();
1187: caddr_t ptr;
1188: {
1189: PS ps;
1190: char buffer [RESBUF];
1191: char save;
1192: int i, size;
1193: register char *str, *sptr;
1194:
1195: if ((ps = ps_alloc (str_open)) == NULLPS) return ;
1196:
1197: if (str_setup (ps,buffer,RESBUF,1) == NOTOK) return ;
1198:
1199: (*func) (ps, ptr, READOUT);
1200: *ps->ps_ptr = 0;
1201:
1202: ps_free(ps);
1203: str = buffer ;
1204: sptr = str;
1205: size = strlen(buffer);
1206:
1207: if (text_state == DN_LIST) free_seq(dnseq);
1208: dnseq = NULLDS;
1209: free_seq(textseq);
1210: textseq = NULLDS;
1211: display_entry = current_entry = 1;
1212: entry_number = 0;
1213: text_state = TEXT;
1214:
1215: for (i = 0; i <= size; i++, sptr++)
1216: if (*sptr == '\n' || *sptr == '\0') {
1217: entry_number++;
1218: save = *sptr ;
1219: *sptr = '\0';
1220:
1221: if (mailformat == greybook && indexstring(str, "rfc822") >= 0)
1222: (void) rfc2jnt(str);
1223: add_seq(&textseq, str);
1224:
1225: str = sptr+1;
1226: *sptr = save;
1227: }
1228:
1229: scrollbar('\0');
1230: }
1231:
1232: quipu_print (func,ptr)
1233: int (*func) (); /* assumes func (PS ,dataptr,(int) format); */
1234: caddr_t ptr;
1235: {
1236: /* log info to pstream */
1237: PS ps;
1238: char buffer [RESBUF];
1239: int count;
1240: register char *str, *sptr;
1241: char save;
1242:
1243: if ((ps = ps_alloc (str_open)) == NULLPS) return ;
1244:
1245: if (str_setup (ps,buffer,RESBUF,1) == NOTOK) return ;
1246:
1247: (*func) (ps,ptr,READOUT);
1248: *ps->ps_ptr = 0;
1249:
1250: ps_free (ps);
1251:
1252: /* print in blocks of 100 bytes-larger seems too much for curses*/
1253: str = buffer;
1254: do {
1255: for (count = 0, sptr = str; *sptr != '\0' &&
1256: count < 100; sptr++, count++);
1257: save = *sptr;
1258: *sptr = 0;
1259: xprint (str);
1260: *sptr = save;
1261: str = sptr;
1262: } while (*sptr != '\0');
1263: }
1264:
1265: quipu_error (err)
1266: struct DSError * err;
1267: {
1268: PS ps;
1269: char buffer [RESBUF];
1270:
1271: if ((ps = ps_alloc(str_open)) == NULLPS) return ;
1272:
1273: if (str_setup (ps, buffer, RESBUF, 1) == NOTOK) return ;
1274: ds_error(ps, err);
1275:
1276: *ps->ps_ptr = 0;
1277: xprint(buffer);
1278: }
1279:
1280: returnmain()
1281: {
1282: QUITFN();
1283: setwidgets (mainwdgts,-1);
1284: rd_start();
1285: scrollbar('\0');
1286: }
1287:
1288: free_filt(filt)
1289: filt_struct *filt;
1290: {
1291: if (filt) {
1292: free_filt(filt->next);
1293:
1294: if (filt->flt_type = ITEM) {
1295: free(filt->fu_cont.item.stroid);
1296: if (filt->fu_cont.item.name) free(filt->fu_cont.item.name);
1297: } else
1298: free_filt(filt->fu_cont.sub_filt);
1299:
1300: free(filt);
1301: } else
1302: return;
1303: }
1304:
1305: get_listed_object(number, wdgt)
1306: char number;
1307: WIDGET *wdgt;
1308: {
1309: int entrynum, count = 0;
1310: char *sptr, *str;
1311: char buffer[1024];
1312:
1313: if (text_state != DN_LIST && text_state != BACK_LIST) {
1314: *wdgt->dstr = '\0';
1315: printdialog(wdgt);
1316: return;
1317: }
1318:
1319: *srchvalue = number;
1320: *(srchvalue+1) = '\0';
1321:
1322: if (wdgt) {
1323: printdialog(wdgt);
1324: dialog(wdgt);
1325: }
1326:
1327: entrynum = atoi(srchvalue);
1328:
1329: if (entrynum > entry_number) {
1330: *wdgt->dstr = '\0';
1331: printdialog(wdgt);
1332: return;
1333: }
1334:
1335: if (sptr = get_from_seq (entrynum, dnseq))
1336: if(!isleaf(sptr)) {
1337: cleartext();
1338: str = get_from_seq(count+1, back_seq);
1339:
1340: while (count < back_buf_num && strcmp(str, base_path)){
1341: count++;
1342: str = get_from_seq(count+1, back_seq);
1343: }
1344:
1345: if (count == back_buf_num) {
1346: add_seq(&back_seq, base_path);
1347: back_buf_num++;
1348: }
1349:
1350: (void) strcpy(base_path, sptr);
1351: make_friendly(friendly_base_path, base_path);
1352: wdgt = getwidget(mainwdgts, '\0');
1353: printdialog(wdgt);
1354: rd_start();
1355: typetoggled = 0;
1356: set_default_type();
1357: } else {
1358: (void) strcpy(buffer, base_path);
1359: (void) strcpy(base_path, sptr);
1360: make_friendly(friendly_base_path, base_path);
1361: rd_start();
1362: (void) strcpy(base_path, buffer);
1363: }
1364: *srchvalue = '\0';
1365: }
1366:
1367: scrollbar(command)
1368: char command;
1369: {
1370: register char *str;
1371: char *base_rdn;
1372: register int rdn_count = 0;
1373: int lines, count = 0;
1374: D_seq thisseq;
1375:
1376: if (!entry_number)
1377: return 0;
1378:
1379: if(command == '[') {
1380: if(display_entry >= entry_number)
1381: return;
1382:
1383: for (count = 0; (display_entry + count) < entry_number &&
1384: count < text_height/2; count++);
1385:
1386: current_entry += count;
1387: } else if(command == ']') {
1388:
1389: for (count = 0; (current_entry - count) > 1 &&
1390: count < text_height/2; count++);
1391:
1392: current_entry -= count;
1393: }
1394:
1395: cleartext();
1396:
1397: switch(text_state) {
1398:
1399: case BACK_LIST:
1400: thisseq = back_seq;
1401: break;
1402:
1403: case DN_LIST:
1404: base_rdn = base_path;
1405: while(*base_rdn != '\0') {
1406: if(*base_rdn == '@')
1407: rdn_count++;
1408: base_rdn++;
1409: }
1410: if (*base_path != 'T') rdn_count++;
1411: thisseq = dnseq;
1412: break;
1413:
1414: case TEXT:
1415: thisseq = textseq;
1416: break;
1417: }
1418:
1419: if (current_entry > entry_number)
1420: current_entry = 1;
1421:
1422: lines = linec()-2;
1423: count = 0;
1424:
1425: for (display_entry = current_entry; display_entry <= entry_number
1426: && gety() < lines; display_entry++) {
1427:
1428: if (text_state == DN_LIST || text_state == BACK_LIST)
1429: xprintint(" %d ", display_entry) ;
1430:
1431: base_rdn = str = get_from_seq(display_entry, thisseq);
1432:
1433: if (text_state == DN_LIST && rdn_count) {
1434: while (rdn_count) {
1435: if (*str == '@') rdn_count--;
1436: str++;
1437: }
1438:
1439: while(*str == ' ') str++;
1440: count = (int) (str - base_rdn);
1441:
1442: } else if (count) str += count;
1443:
1444: if (str) {
1445: if (text_state != TEXT) {
1446: make_friendly(friendly_name, str);
1447: xprint(friendly_name);
1448: } else
1449: xprint(str);
1450: xprint("\n");
1451: }
1452: }
1453:
1454: if (text_state == DN_LIST)
1455: if (current_entry >= entry_number) xprint("<List finished>");
1456: else xprintint("<Total of %d entries>", entry_number);
1457:
1458: printbar(entry_number, current_entry, display_entry-current_entry);
1459: display_entry--;
1460: return 1;
1461: }
1462:
1463: make_friendly(fstr, str)
1464: char *fstr;
1465: register char *str;
1466: {
1467: register char *end_ptr;
1468: char save;
1469:
1470: *fstr = '\0';
1471: if (!strcmp(str, "The World")) {
1472: (void) strcpy(fstr, str);
1473: return;
1474: }
1475:
1476: while (*str != '\0') {
1477: while (*str != '=') str++;
1478: while (*str == ' ') str++;
1479:
1480: end_ptr = ++str;
1481: while (*end_ptr != '@' && *end_ptr != '\0') end_ptr++;
1482: save = *end_ptr;
1483: *end_ptr = '\0';
1484: if (*fstr == '\0')
1485: (void) strcpy(fstr, str);
1486: else
1487: (void) strcat(fstr, str);
1488: *end_ptr = save;
1489: str = end_ptr;
1490: if (*str != '\0')
1491: (void) strcat(fstr, ", ");
1492: }
1493: }
1494:
1495:
1496: goto_addr()
1497: {
1498: set_default_type();
1499: rd_start();
1500: }
1501:
1502: int
1503: isleaf(name)
1504: char *name;
1505: {
1506: struct ds_list_arg list_arg;
1507: struct ds_list_result list_result;
1508:
1509: struct ds_read_arg read_arg;
1510: struct ds_read_result read_result;
1511:
1512: struct DSError list_error, read_error;
1513: char entry_str[1024];
1514:
1515: if (get_default_service (&read_arg.rda_common) != 0) return(1);
1516:
1517: read_arg.rda_common.ca_servicecontrol.svc_options = 1;
1518: read_arg.rda_eis.eis_allattributes = FALSE;
1519: read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
1520: read_arg.rda_eis.eis_select = oclass;
1521:
1522: read_arg.rda_object = (*name? str2dn(name): NULLDN);
1523: if (ds_read (&read_arg,&read_error,&read_result) != DS_OK) return(1);
1524: else {
1525: if (read_result.rdr_entry.ent_attr == NULLATTR) return(0);
1526: entry2str((caddr_t) read_result.rdr_entry.ent_attr, entry_str, 1024);
1527: if (issubstr(entry_str, "NonLeaf")) return(0);
1528: }
1529: if (get_default_service (&list_arg.lsa_common) != 0) return(1);
1530:
1531: list_arg.lsa_common.ca_servicecontrol.svc_sizelimit = 1;
1532: list_arg.lsa_common.ca_servicecontrol.svc_options = 1;
1533:
1534: if (*name)
1535: list_arg.lsa_object = str2dn(name);
1536: else
1537: list_arg.lsa_object = NULLDN;
1538:
1539: if (ds_list (&list_arg,&list_error,&list_result) != DS_OK)
1540: return (1);
1541: else {
1542: if (list_result.lsr_subordinates == NULLSUBORD) return(1);
1543: else return(0);
1544: }
1545: }
1546:
1547: entry2str(ptr, cptr, size)
1548: caddr_t ptr;
1549: char *cptr;
1550: int size;
1551: {
1552: PS ps;
1553:
1554: if ((ps = ps_alloc (str_open)) == NULLPS) return ;
1555: if (str_setup (ps, cptr, size, 1) == NOTOK) return ;
1556:
1557: as_print(ps, (Attr_Sequence) ptr, READOUT);
1558: *ps->ps_ptr = 0;
1559:
1560: ps_free(ps);
1561: }
1562:
1563: int issubstr(str, substr)
1564: char *str;
1565: char *substr;
1566: {
1567: register char *sptr;
1568: char c;
1569: int substrlen = strlen(substr);
1570: int count;
1571:
1572: if (*substr == '\0' || *str == '\0') return(0);
1573:
1574: sptr = str;
1575: c = *substr;
1576:
1577: while (1) {
1578: while (*sptr != '\0' && *sptr != c) sptr++;
1579: if (*sptr == '\0') return(0);
1580: for (count = 0; count >= 0 && count < substrlen; count++) {
1581: if (sptr[count] == '\0') return(0);
1582: else if (substr[count] != sptr[count]) count = -2;
1583: }
1584: if (count == substrlen) return(1);
1585: }
1586: }
1587:
1588: int indexstring(string, substring)
1589: char *string,
1590: *substring;
1591: {
1592: register char *sub, *str;
1593: char c, s;
1594: int indx = 0;
1595:
1596: while (1) {
1597: str = string + indx;;
1598: if (*str == '\0') return(-1);
1599: sub = substring;
1600:
1601: if (*str == *sub) {
1602: s = *str;
1603: c = *sub;
1604: while(c == s && c != '\0') {
1605: c = *++sub;
1606: s = *++str;
1607: }
1608: if (c == '\0') return((int) indx);
1609: else if(s == '\0') return(-1);
1610: }
1611: indx++;
1612: }
1613: }
1614:
1615: rfc2jnt(string)
1616: char *string;
1617: {
1618: char reversed[STRINGLEN];
1619: char front[STRINGLEN];
1620: register char *part;
1621: char *mailbox;
1622:
1623: mailbox = string;
1624: while (*mailbox != '-') mailbox++;
1625:
1626: reversed[0] = '\0';
1627: part = string + strlen(string);
1628:
1629: if (*part != '\0') return;
1630:
1631: while(1) {
1632: while (*part != '.' && *part != '@') --part;
1633:
1634: if (*part == '.') {
1635: if (reversed[0] != '\0') (void) strcat(reversed, ".");
1636: part++;
1637: (void) strcat(reversed, part);
1638: *--part = '\0';
1639: --part;
1640: } else {
1641: part++;
1642: (void) strcat(reversed, ".");
1643: (void) strcat(reversed, part);
1644: *part-- = '\0';
1645: while (!isspace(*part)) --part;
1646: ++part;
1647: (void) strcpy(front, part);
1648: (void) strcpy(string, "mailbox - ");
1649: (void) strcat(string, front);
1650: (void) strcat(string, reversed);
1651: return;
1652: }
1653: }
1654: }
1655:
1656: struct attrcomp *
1657: sort_attrs(entry_attrs)
1658: struct attrcomp *entry_attrs;
1659: {
1660: struct attrcomp *last, *next, *curr, *first, *firstn;
1661:
1662: first = curr = entry_attrs;
1663: firstn = last = next = 0;
1664:
1665: while (curr)
1666: if (!strcmp("2.5.4.3", curr->attr_type->oa_ot.ot_stroid) ||
1667: !strcmp("2.5.4.4", curr->attr_type->oa_ot.ot_stroid) ||
1668: !strcmp("0.9.2342.19200300.100.1.3",
1669: curr->attr_type->oa_ot.ot_stroid) ||
1670: !strcmp("0.9.2342.19200300.100.1.2",
1671: curr->attr_type->oa_ot.ot_stroid) ||
1672: !strcmp("2.5.4.20", curr->attr_type->oa_ot.ot_stroid)) {
1673:
1674: if (first == curr) first = curr->attr_link;
1675:
1676: if (next)
1677: next->attr_link = curr;
1678: else
1679: firstn = curr;
1680:
1681: next = curr;
1682:
1683: if (last)
1684: last->attr_link = curr->attr_link;
1685:
1686: curr = curr->attr_link;
1687: next->attr_link = 0;
1688: } else {
1689: last = curr;
1690: curr = curr->attr_link;
1691: }
1692:
1693: if (next) {
1694: next->attr_link = first;
1695: return firstn;
1696: } else
1697: return first;
1698: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.