source: trunk/athena/bin/discuss/libds/stubs.c @ 2741

Revision 2741, 16.9 KB checked in by srz, 34 years ago (diff)
Added add_trn2 & get_trn_info3 routines, for signatures.
Line 
1/*
2 *
3 *      Copyright (C) 1988, 1989 by the Massachusetts Institute of Technology
4 *      Developed by the MIT Student Information Processing Board (SIPB).
5 *      For copying information, see the file mit-copyright.h in this release.
6 *
7 */
8/*
9 *
10 *      $Source: /afs/dev.mit.edu/source/repository/athena/bin/discuss/libds/stubs.c,v $
11 *      $Header: /afs/dev.mit.edu/source/repository/athena/bin/discuss/libds/stubs.c,v 1.15 1990-02-24 18:53:16 srz Exp $
12 *
13 * stubs.c -- These are stubs that handle the calling of routines.
14 *
15 *      $Log: not supported by cvs2svn $
16 * Revision 1.14  89/06/03  00:21:54  srz
17 * Added standard copyright notice.
18 *
19 * Revision 1.13  89/03/27  00:33:07  srz
20 * Null out fields, so that callers can FREE() fields of trn_info & mtg_info
21 * after calling.
22 *
23 * Revision 1.12  89/01/29  17:17:59  srz
24 * Added flag routines, and version check.
25 *
26 * Revision 1.11  89/01/04  20:52:00  raeburn
27 * Still fixing includes..
28 *
29 * Revision 1.10  88/10/16  14:04:50  raeburn
30 * Changed includes and type names.
31 *
32 * Revision 1.9  87/10/06  02:36:45  spook
33 * Fixed error detected by High C compiler.
34 *
35 * Revision 1.8  87/07/20  20:57:47  srz
36 * Changed name of whoami to dwhoami (too generic of a name)
37 *
38 * Revision 1.7  87/07/08  02:00:16  wesommer
39 * Added whoami(), dsc_whoami() (the server support was always there.
40 *
41 * Revision 1.6  87/06/27  01:10:55  spook
42 * *** empty log message ***
43 *
44 * Revision 1.5  87/04/11  00:06:13  srz
45 * Added RCS junk
46 *
47 *
48 */
49#ifndef lint
50static char rcsid_stubs_c[] =
51    "$Header: /afs/dev.mit.edu/source/repository/athena/bin/discuss/libds/stubs.c,v 1.15 1990-02-24 18:53:16 srz Exp $";
52#endif lint
53
54/* Derived from CORE.PAS 06/21/86 by SRZ */
55
56#include <discuss/interface.h>
57#include "rpc.h"
58#include <discuss/tfile.h>
59#include <discuss/acl.h>
60
61extern bool recvbool();
62extern char *recvstr();
63dsc_acl *recv_acl();
64
65static char discuss[] = "discuss";
66
67/*
68 *
69 * add_trn () --
70 * adds a transaction to the current meeting, either as a reply or an
71 * original transaction.  Returns an error code, and the transaction number
72 * given to the transaction
73 *
74 */
75add_trn (mtg_name, source_file, subject, reply_trn, result_trn, result)
76char *mtg_name;
77tfile source_file;
78char *subject;
79trn_nums reply_trn;             /* trn replying to;  0 if original */
80trn_nums *result_trn;           /* trn number given to added trn */
81int *result;
82{
83     startsend(ADD_TRN);
84     if (rpc_err) { *result = rpc_err; return; }
85     sendstr(mtg_name);
86     sendfile(source_file);
87     sendstr(subject);
88     sendint(reply_trn);
89     sendit(discuss);
90     senddata(source_file);
91     if (rpc_err) { *result = rpc_err; return; }
92     recvreply ();
93     if (rpc_err) { *result = rpc_err; return; }
94     *result_trn = recvint();
95     *result = recvint();
96     if (rpc_err) { *result = rpc_err; return; }
97     return;
98}
99
100/*
101 *
102 * add_trn2 () --
103 * adds a transaction to the current meeting, either as a reply or an
104 * original transaction.  Allows a signature to be given.
105 * Returns an error code, and the transaction number given to the transaction
106 *
107 */
108add_trn2 (mtg_name, source_file, subject, signature, reply_trn, result_trn, result)
109char *mtg_name;
110tfile source_file;
111char *subject;
112char *signature;
113trn_nums reply_trn;             /* trn replying to;  0 if original */
114trn_nums *result_trn;           /* trn number given to added trn */
115int *result;
116{
117     startsend(ADD_TRN2);
118     if (rpc_err) { *result = rpc_err; return; }
119     sendstr(mtg_name);
120     sendfile(source_file);
121     sendstr(subject);
122     sendstr(signature);
123     sendint(reply_trn);
124     sendit(discuss);
125     senddata(source_file);
126     if (rpc_err) { *result = rpc_err; return; }
127     recvreply ();
128     if (rpc_err) { *result = rpc_err; return; }
129     *result_trn = recvint();
130     *result = recvint();
131     if (rpc_err) { *result = rpc_err; return; }
132     return;
133}
134
135/*
136 *
137 * get_trn_info () --
138 * returns information about the given transaction in info, with an error
139 * code as its return argument
140 *
141 */
142get_trn_info (mtg_name, trn, info, result)
143char *mtg_name;
144trn_nums trn;
145trn_info *info;
146int *result;
147{
148     info -> subject = NULL;                    /* Not allocated */
149     info -> author = NULL;
150     startsend(GET_TRN_INFO);
151     if (rpc_err) { *result = rpc_err; return; }
152     sendstr(mtg_name);
153     sendint(trn);
154     sendit(discuss);
155     if (rpc_err) { *result = rpc_err; return; }
156     recvreply();
157     if (rpc_err) { *result = rpc_err; return; }
158     recv_trn_info(info);
159     *result = recvint();
160     if (rpc_err) { *result = rpc_err; return; }
161     return;
162}
163
164/*
165 *
166 * get_trn_info2 () --
167 * returns information about the given transaction in info, with an error
168 * code as its return argument
169 *
170 */
171get_trn_info2 (mtg_name, trn, info, result)
172char *mtg_name;
173trn_nums trn;
174trn_info2 *info;
175int *result;
176{
177     info -> subject = NULL;                    /* Not allocated */
178     info -> author = NULL;
179     startsend(GET_TRN_INFO2);
180     if (rpc_err) { *result = rpc_err; return; }
181     sendstr(mtg_name);
182     sendint(trn);
183     sendit(discuss);
184     if (rpc_err) { *result = rpc_err; return; }
185     recvreply();
186     if (rpc_err) { *result = rpc_err; return; }
187     recv_trn_info2(info);
188     *result = recvint();
189     if (rpc_err) { *result = rpc_err; return; }
190     return;
191}
192
193/*
194 *
195 * get_trn_info3 () --
196 * returns information about the given transaction in info, with an error
197 * code as its return argument
198 *
199 */
200get_trn_info3 (mtg_name, trn, info, result)
201char *mtg_name;
202trn_nums trn;
203trn_info3 *info;
204int *result;
205{
206     info -> subject = NULL;                    /* Not allocated */
207     info -> author = NULL;
208     startsend(GET_TRN_INFO3);
209     if (rpc_err) { *result = rpc_err; return; }
210     sendstr(mtg_name);
211     sendint(trn);
212     sendit(discuss);
213     if (rpc_err) { *result = rpc_err; return; }
214     recvreply();
215     if (rpc_err) { *result = rpc_err; return; }
216     recv_trn_info3(info);
217     *result = recvint();
218     if (rpc_err) { *result = rpc_err; return; }
219     return;
220}
221
222
223/*
224 *
225 * delete_trn () --
226 * deletes the given transaction from the current meeting.  Returns an
227 * error code
228 *
229 */
230delete_trn (mtg_name, trn, result)
231char *mtg_name;
232trn_nums trn;
233int *result;
234{
235     startsend(DELETE_TRN);
236     if (rpc_err) { *result = rpc_err; return; }
237     sendstr(mtg_name);
238     sendint(trn);
239     sendit(discuss);
240     if (rpc_err) { *result = rpc_err; return; }
241     recvreply();
242     if (rpc_err) { *result = rpc_err; return; }
243     *result = recvint();
244     if (rpc_err) { *result = rpc_err; return; }
245     return;
246}
247
248/*
249 *
250 * retrieve_trn () --
251 * retrieves a previously deleted transaction from the current meeting, if
252 * possible.  trn must refer to a deleted transaction.  An error code is
253 * returned
254 *
255 */
256retrieve_trn (mtg_name, trn, result)
257char *mtg_name;
258trn_nums trn;
259int *result;
260{
261     startsend(RETRIEVE_TRN);
262     if (rpc_err) { *result = rpc_err; return; }
263     sendstr (mtg_name);
264     sendint (trn);
265     sendit(discuss);
266     if (rpc_err) { *result = rpc_err; return; }
267     recvreply();
268     if (rpc_err) { *result = rpc_err; return; }
269     *result = recvint();
270     if (rpc_err) { *result = rpc_err; return; }
271     return;
272}
273
274
275
276/*
277 *
278 * create_mtg () --
279 * Creates a new meeting with the given long_mtg name, where location is the
280 * it's place in the hierarchy, and the long_mtg_name is its canonical name.
281 * The chairman of the new meeting is the current user.
282 *
283 */
284create_mtg (location, long_mtg_name, public, result)
285char *location,*long_mtg_name;
286bool public;
287int *result;
288{
289     startsend(CREATE_MTG);
290     if (rpc_err) { *result = rpc_err; return; }
291     sendstr(location);
292     sendstr(long_mtg_name);
293     sendbool(public);
294     sendit(discuss);
295     if (rpc_err) { *result = rpc_err; return; }
296     recvreply();
297     if (rpc_err) { *result = rpc_err; return; }
298     *result = recvint();
299     if (rpc_err) { *result = rpc_err; return; }
300     return;
301}
302
303
304/*
305 *
306 * old_get_mtg_info () --
307 * returns information about the given meeting.  Return argument is an
308 * error code
309 *
310 */
311old_get_mtg_info (mtg_name, info, result)
312char *mtg_name;
313mtg_info *info;
314int *result;
315{
316     info -> location = NULL;
317     info -> long_name = NULL;
318     info -> chairman = NULL;
319     startsend(OLD_GET_MTG_INFO);
320     if (rpc_err) { *result = rpc_err; return; }
321     sendstr(mtg_name);
322     sendit(discuss);
323     if (rpc_err) { *result = rpc_err; return; }
324     recvreply();
325     if (rpc_err) { *result = rpc_err; return; }
326     old_recv_mtg_info(info);
327     *result = recvint();
328     if (rpc_err) { *result = rpc_err; return; }
329     return;
330}
331/*
332 *
333 * get_mtg_info () --
334 * returns information about the given meeting.  Return argument is an
335 * error code
336 *
337 */
338get_mtg_info (mtg_name, info, result)
339char *mtg_name;
340mtg_info *info;
341int *result;
342{
343     info -> location = NULL;
344     info -> long_name = NULL;
345     info -> chairman = NULL;
346     info -> access_modes = NULL;
347     startsend(GET_MTG_INFO);
348     if (rpc_err) { *result = rpc_err; return; }
349     sendstr(mtg_name);
350     sendit(discuss);
351     if (rpc_err) { *result = rpc_err; return; }
352     recvreply();
353     if (rpc_err) { *result = rpc_err; return; }
354     recv_mtg_info(info);
355     *result = recvint();
356     if (rpc_err) { *result = rpc_err; return; }
357     return;
358}
359
360/*
361 *
362 * get_trn () --
363 * gets the given transaction, and feeds it through dest_file.  Returns an
364 * error code
365 *
366 */
367get_trn (mtg_name, trn, dest_file, result)
368char *mtg_name;
369trn_nums trn;
370tfile dest_file;
371int *result;
372{
373     startsend(GET_TRN);
374     if (rpc_err) { *result = rpc_err; return; }
375     sendstr(mtg_name);
376     sendint(trn);
377     sendfile(dest_file);
378     sendit(discuss);
379     if (rpc_err) { *result = rpc_err; return; }
380     recvdata(dest_file);
381     recvreply();
382     if (rpc_err) { *result = rpc_err; return; }
383     *result = recvint();
384     if (rpc_err) { *result = rpc_err; return; }
385     return;
386}
387
388/*
389 *
390 * remove_mtg () --
391 * removes the given meeting from the meeting list.  This should
392 * probably go ahead and physically remove the contents of the meeting
393 * but that's not obvious if we have the access to do that.
394 *
395 */
396remove_mtg (mtg_name, result)
397char *mtg_name;
398int *result;
399{
400     startsend(REMOVE_MTG);
401     if (rpc_err) { *result = rpc_err; return; }
402     sendstr(mtg_name);
403     sendit(discuss);
404     if (rpc_err) { *result = rpc_err; return; }
405     recvreply();
406     if (rpc_err) { *result = rpc_err; return; }
407     *result = recvint();
408     if (rpc_err) { *result = rpc_err; return; }
409     return;
410}
411/*
412 *
413 * updated_mtg () -- Quick procedure to check if the meeting is updated
414 *                   with respect to a given time and transaction number.
415 *
416 */
417updated_mtg (mtg_name, date_attended, last, updated, result)
418char *mtg_name;
419int date_attended, last;
420bool *updated;
421int *result;
422{
423     startsend(UPDATED_MTG);
424     if (rpc_err) { *result = rpc_err; return; }
425     sendstr(mtg_name);
426     sendint(date_attended);
427     sendint(last);
428     sendit(discuss);
429     if (rpc_err) { *result = rpc_err; return; }
430     recvreply();
431     if (rpc_err) { *result = rpc_err; return; }
432     *updated = recvbool();
433     *result = recvint();
434     if (rpc_err) { *result = rpc_err; return; }
435     return;
436}
437#define rpccheck if (rpc_err) { *result = rpc_err; return; }
438/*
439 * get_acl () -- Get access control list.
440 */
441get_acl(mtg_name, result, list)
442        char *mtg_name;
443        int *result;            /* RETURN */
444        dsc_acl **list;         /* RETURN */
445{
446        startsend(GET_ACL);
447        rpccheck;
448        sendstr(mtg_name);
449        sendit(discuss);
450        rpccheck;
451        recvreply();
452        if (rpc_err) { *result = rpc_err; return; }
453        *result = recvint();
454        *list = recv_acl();
455        rpccheck;
456        return;
457}
458
459get_access(mtg_name, princ_name, modes, result)
460        char *mtg_name;
461        char *princ_name;
462        char **modes;           /* RETURN */
463        int *result;            /* RETURN */
464{
465        *modes = NULL;     
466        startsend(GET_ACCESS);
467        rpccheck;
468        sendstr(mtg_name);
469        sendstr(princ_name);
470        sendit(discuss);
471        rpccheck;
472        recvreply();
473        if (rpc_err) { *result = rpc_err; return; }
474        *modes = recvstr();
475        *result = recvint();
476        rpccheck;
477        return;
478}
479set_access(mtg_name, princ_name, modes, result)
480        char *mtg_name;
481        char *princ_name;
482        char *modes;
483        int *result;            /* RETURN */
484{
485        startsend(SET_ACCESS);
486        rpccheck;
487        sendstr(mtg_name);
488        sendstr(princ_name);
489        sendstr(modes);
490        sendit(discuss);
491        rpccheck;
492        recvreply();
493        if (rpc_err) { *result = rpc_err; return; }
494        *result = recvint();
495        rpccheck;
496        return;
497}
498
499delete_access(mtg_name, princ_name, result)
500        char *mtg_name;
501        char *princ_name;
502        int *result;            /* RETURN */
503{
504        startsend(DELETE_ACCESS);
505        rpccheck;
506        sendstr(mtg_name);
507        sendstr(princ_name);
508        sendit(discuss);
509        rpccheck;
510        recvreply();
511        if (rpc_err) { *result = rpc_err; return; }
512        *result = recvint();
513        rpccheck;
514        return;
515}
516
517set_trn_flags(mtg_name, trn, flags, result)
518char *mtg_name;
519trn_nums trn;
520int flags;
521int *result;
522{
523     startsend(SET_TRN_FLAGS);
524     if (rpc_err) { *result = rpc_err; return; }
525     sendstr(mtg_name);
526     sendint(trn);
527     sendint(flags);
528     sendit(discuss);
529     if (rpc_err) { *result = rpc_err; return; }
530     recvreply();
531     if (rpc_err) { *result = rpc_err; return; }
532     *result = recvint();
533     if (rpc_err) { *result = rpc_err; return; }
534     return;
535}
536
537
538dwhoami(ident, result)
539        char **ident;
540        int *result;
541{
542        *result = 0;
543        *ident = NULL;
544        startsend(WHO_AM_I);
545        rpccheck;
546        sendit(discuss);
547        rpccheck;
548        recvreply();
549        if (rpc_err) { *result = rpc_err; return; }
550        *ident = recvstr();
551        rpccheck;
552        return;
553}
554
555get_server_version()
556{
557        int vers_num,result;
558
559        startsend(GET_SERVER_VERSION);
560        if (rpc_err) return (SERVER_0);
561        sendit(discuss);
562        if (rpc_err) return (SERVER_0);
563        recvreply();
564        if (rpc_err) return (SERVER_0);
565        vers_num = recvint();
566        if (rpc_err) return (SERVER_0);
567        result = recvint();
568        if (rpc_err) return (SERVER_0);
569        return(vers_num);
570}
571
572/*
573 *
574 * recv_trn_info -- recv a trn_info struct.
575 *
576 */
577recv_trn_info(tinfo)
578trn_info *tinfo;
579{
580     tinfo -> version = recvint ();
581     tinfo -> current = recvint ();
582     tinfo -> prev = recvint ();
583     tinfo -> next = recvint ();
584     tinfo -> pref = recvint ();
585     tinfo -> nref = recvint ();
586     tinfo -> fref = recvint ();
587     tinfo -> lref = recvint ();
588     tinfo -> chain_index = recvint ();
589     tinfo -> date_entered = recvint ();
590     tinfo -> num_lines = recvint ();
591     tinfo -> num_chars = recvint ();
592     tinfo -> subject = recvstr ();
593     tinfo -> author = recvstr ();
594}
595
596/*
597 *
598 * recv_trn_info2 -- recv a trn_info2 struct.
599 *
600 */
601recv_trn_info2(tinfo)
602trn_info2 *tinfo;
603{
604     tinfo -> version = recvint ();
605     tinfo -> current = recvint ();
606     tinfo -> prev = recvint ();
607     tinfo -> next = recvint ();
608     tinfo -> pref = recvint ();
609     tinfo -> nref = recvint ();
610     tinfo -> fref = recvint ();
611     tinfo -> lref = recvint ();
612     tinfo -> chain_index = recvint ();
613     tinfo -> date_entered = recvint ();
614     tinfo -> num_lines = recvint ();
615     tinfo -> num_chars = recvint ();
616     tinfo -> subject = recvstr ();
617     tinfo -> author = recvstr ();
618     tinfo -> flags = recvint ();
619}
620
621/*
622 *
623 * recv_trn_info3 -- recv a trn_info2 struct.
624 *
625 */
626recv_trn_info3(tinfo)
627trn_info3 *tinfo;
628{
629     tinfo -> version = recvint ();
630     tinfo -> current = recvint ();
631     tinfo -> prev = recvint ();
632     tinfo -> next = recvint ();
633     tinfo -> pref = recvint ();
634     tinfo -> nref = recvint ();
635     tinfo -> fref = recvint ();
636     tinfo -> lref = recvint ();
637     tinfo -> chain_index = recvint ();
638     tinfo -> date_entered = recvint ();
639     tinfo -> num_lines = recvint ();
640     tinfo -> num_chars = recvint ();
641     tinfo -> subject = recvstr ();
642     tinfo -> author = recvstr ();
643     tinfo -> flags = recvint ();
644     tinfo -> signature = recvstr ();
645}
646   
647/*
648 *
649 * old_recv_mtg_info -- Recv a mtg info struct.
650 *
651 */
652old_recv_mtg_info(minfo)
653mtg_info *minfo;
654{
655     minfo -> version = recvint ();
656     minfo -> location = recvstr ();
657     minfo -> long_name = recvstr ();
658     minfo -> chairman = recvstr ();
659     minfo -> first = recvint ();
660     minfo -> last = recvint ();
661     minfo -> lowest = recvint ();
662     minfo -> highest = recvint ();
663     minfo -> date_created = recvint ();
664     minfo -> date_modified = recvint ();
665     minfo -> public_flag = recvbool ();
666}
667
668/*
669 *
670 * recv_mtg_info -- Recv a mtg info struct.
671 *
672 */
673recv_mtg_info(minfo)
674mtg_info *minfo;
675{
676     minfo -> version = recvint ();
677     minfo -> location = recvstr ();
678     minfo -> long_name = recvstr ();
679     minfo -> chairman = recvstr ();
680     minfo -> first = recvint ();
681     minfo -> last = recvint ();
682     minfo -> lowest = recvint ();
683     minfo -> highest = recvint ();
684     minfo -> date_created = recvint ();
685     minfo -> date_modified = recvint ();
686     minfo -> public_flag = recvbool ();
687     minfo -> access_modes = recvstr ();
688}
689
690dsc_acl *recv_acl()
691{
692        char *malloc();
693        /* The following code would lose points in 6.170... */
694        register dsc_acl *result = (dsc_acl *) malloc(sizeof(dsc_acl));
695        register dsc_acl_entry *ae;
696        register unsigned int len;
697        len = recvint();
698        result->acl_length = len;
699        if (len > 1000) /* Bogus! */ {
700                /*XXX Put some error checking in here */
701        }
702        result->acl_entries =
703            (dsc_acl_entry *) malloc(sizeof(dsc_acl_entry) * len);
704        for (ae = result->acl_entries; len; --len, ++ae) {
705                ae->modes = recvstr(); 
706                ae->principal = recvstr();
707        }
708        return result;
709}
710               
Note: See TracBrowser for help on using the repository browser.