source: zwrite.c @ c529ac8

release-1.4release-1.5release-1.6release-1.7release-1.8release-1.9
Last change on this file since c529ac8 was c529ac8, checked in by Anders Kaseorg <andersk@mit.edu>, 12 years ago
Add new function strs, to (later) cast char *const * to const char *const *. Signed-off-by: Anders Kaseorg <andersk@mit.edu>
  • Property mode set to 100644
File size: 8.7 KB
Line 
1#include <string.h>
2#include <pwd.h>
3#include <sys/types.h>
4#include <unistd.h>
5#include "owl.h"
6
7int owl_zwrite_create_from_line(owl_zwrite *z, char *line)
8{
9  int argc, badargs, myargc, i, len;
10  char **argv, **myargv;
11  char *msg = NULL;
12
13  badargs=0;
14 
15  /* start with null entries */
16  z->realm=NULL;
17  z->class=NULL;
18  z->inst=NULL;
19  z->opcode=NULL;
20  z->zsig=NULL;
21  z->message=NULL;
22  z->cc=0;
23  z->noping=0;
24  owl_list_create(&(z->recips));
25
26  /* parse the command line for options */
27  argv=owl_parseline(line, &argc);
28  myargv=strs(argv);
29  if (argc<0) {
30    owl_function_error("Unbalanced quotes in zwrite");
31    return(-1);
32  }
33  myargc=argc;
34  if (myargc && *(myargv[0])!='-') {
35    myargc--;
36    myargv++;
37  }
38  while (myargc) {
39    if (!strcmp(myargv[0], "-c")) {
40      if (myargc<2) {
41        badargs=1;
42        break;
43      }
44      z->class=owl_validate_utf8(myargv[1]);
45      myargv+=2;
46      myargc-=2;
47    } else if (!strcmp(myargv[0], "-i")) {
48      if (myargc<2) {
49        badargs=1;
50        break;
51      }
52      z->inst=owl_validate_utf8(myargv[1]);
53      myargv+=2;
54      myargc-=2;
55    } else if (!strcmp(myargv[0], "-r")) {
56      if (myargc<2) {
57        badargs=1;
58        break;
59      }
60      z->realm=owl_validate_utf8(myargv[1]);
61      myargv+=2;
62      myargc-=2;
63    } else if (!strcmp(myargv[0], "-s")) {
64      if (myargc<2) {
65        badargs=1;
66        break;
67      }
68      z->zsig=owl_validate_utf8(myargv[1]);
69      myargv+=2;
70      myargc-=2;
71    } else if (!strcmp(myargv[0], "-O")) {
72      if (myargc<2) {
73        badargs=1;
74        break;
75      }
76      z->opcode=owl_validate_utf8(myargv[1]);
77      myargv+=2;
78      myargc-=2;
79    } else if (!strcmp(myargv[0], "-m")) {
80      if (myargc<2) {
81        badargs=1;
82        break;
83      }
84      /* we must already have users or a class or an instance */
85      if (owl_list_get_size(&(z->recips))<1 && (!z->class) && (!z->inst)) {
86        badargs=1;
87        break;
88      }
89
90      /* Once we have -m, gobble up everything else on the line */
91      myargv++;
92      myargc--;
93      len = 0;
94      for (i=0;i<myargc;i++) {
95        len += strlen(myargv[i-1]) + 1;
96      }
97      msg = owl_malloc(len);
98      msg[0] = '\0';
99      while (myargc) {
100        strcat(msg, myargv[0]);
101        strcat(msg, " ");
102        myargc--;
103        myargv++;
104      }
105      msg[strlen(msg)-1] = '\0';
106      break;
107    } else if (!strcmp(myargv[0], "-C")) {
108      z->cc=1;
109      myargv++;
110      myargc--;
111    } else if (!strcmp(myargv[0], "-n")) {
112      z->noping=1;
113      myargv++;
114      myargc--;
115    } else {
116      /* anything unattached is a recipient */
117      owl_list_append_element(&(z->recips), owl_validate_utf8(myargv[0]));
118      myargv++;
119      myargc--;
120    }
121  }
122
123  owl_parsefree(argv, argc);
124
125  if (badargs) {
126    return(-1);
127  }
128
129  if (z->class == NULL &&
130      z->inst == NULL &&
131      owl_list_get_size(&(z->recips))==0) {
132    owl_function_error("You must specify a recipient for zwrite");
133    return(-1);
134  }
135
136  /* now deal with defaults */
137  if (z->class==NULL) z->class=owl_strdup("message");
138  if (z->inst==NULL) z->inst=owl_strdup("personal");
139  if (z->realm==NULL) z->realm=owl_strdup("");
140  if (z->opcode==NULL) z->opcode=owl_strdup("");
141  /* z->message is allowed to stay NULL */
142
143  if(msg) {
144    owl_zwrite_set_message(z, msg);
145    owl_free(msg);
146  }
147
148  return(0);
149}
150
151void owl_zwrite_populate_zsig(owl_zwrite *z)
152{
153  char *zsigproc, *zsigowlvar, *zsigzvar, *ptr;
154  struct passwd *pw;
155
156  /* get a zsig, if not given */
157  if (z->zsig==NULL) {
158    zsigproc = owl_global_get_zsigproc(&g);
159    zsigowlvar = owl_global_get_zsig(&g);
160    zsigzvar = owl_zephyr_get_variable("zwrite-signature");
161
162    if (zsigowlvar && *zsigowlvar) {
163      z->zsig=owl_validate_utf8(zsigowlvar);
164    } else if (zsigproc && *zsigproc) {
165      FILE *file;
166      char buff[LINE], *openline;
167     
168      /* simple hack for now to nuke stderr */
169      openline=owl_malloc(strlen(zsigproc)+40);
170      strcpy(openline, zsigproc);
171#if !(OWL_STDERR_REDIR)
172      strcat(openline, " 2> /dev/null");
173#endif
174      file=popen(openline, "r");
175      owl_free(openline);
176      if (!file) {
177        if (zsigzvar && *zsigzvar) {
178          z->zsig=owl_validate_utf8(zsigzvar);
179        }
180      } else {
181        z->zsig=owl_malloc(LINE*5);
182        strcpy(z->zsig, "");
183        while (fgets(buff, LINE, file)) { /* wrong sizing */
184          strcat(z->zsig, buff);
185        }
186        pclose(file);
187        if (z->zsig[strlen(z->zsig)-1]=='\n') {
188          z->zsig[strlen(z->zsig)-1]='\0';
189        }
190      }
191    } else if (zsigzvar) {
192      z->zsig=owl_validate_utf8(zsigzvar);
193    } else if (((pw=getpwuid(getuid()))!=NULL) && (pw->pw_gecos)) {
194      z->zsig=owl_validate_utf8(pw->pw_gecos);
195      ptr=strchr(z->zsig, ',');
196      if (ptr) {
197        ptr[0]='\0';
198      }
199    }
200  }
201}
202
203void owl_zwrite_send_ping(owl_zwrite *z)
204{
205  int i, j;
206  char *to;
207
208  if (z->noping) return;
209 
210  if (strcasecmp(z->class, "message")) {
211    return;
212  }
213
214  /* if there are no recipients we won't send a ping, which
215     is what we want */
216  j=owl_list_get_size(&(z->recips));
217  for (i=0; i<j; i++) {
218    if (strcmp(z->realm, "")) {
219      to = owl_sprintf("%s@%s", (char *) owl_list_get_element(&(z->recips), i), z->realm);
220    } else {
221      to = owl_strdup(owl_list_get_element(&(z->recips), i));
222    }
223    send_ping(to, z->class, z->inst);
224    owl_free(to);
225  }
226
227}
228
229void owl_zwrite_set_message(owl_zwrite *z, char *msg)
230{
231  int i, j;
232  char *toline = NULL;
233  char *tmp = NULL, *tmp2;
234
235  if (z->message) owl_free(z->message);
236
237  j=owl_list_get_size(&(z->recips));
238  if (j>0 && z->cc) {
239    toline = owl_strdup( "CC: ");
240    for (i=0; i<j; i++) {
241      tmp = toline;
242      if (strcmp(z->realm, "")) {
243        toline = owl_sprintf( "%s%s@%s ", toline, (char *) owl_list_get_element(&(z->recips), i), z->realm);
244      } else {
245        toline = owl_sprintf( "%s%s ", toline, (char *) owl_list_get_element(&(z->recips), i));
246      }
247      owl_free(tmp);
248      tmp = NULL;
249    }
250    tmp = owl_validate_utf8(msg);
251    tmp2 = owl_text_expand_tabs(tmp);
252    z->message=owl_sprintf("%s\n%s", toline, tmp2);
253    owl_free(toline);
254    owl_free(tmp);
255    owl_free(tmp2);
256  } else {
257    tmp=owl_validate_utf8(msg);
258    z->message=owl_text_expand_tabs(tmp);
259    owl_free(tmp);
260  }
261}
262
263char *owl_zwrite_get_message(owl_zwrite *z)
264{
265  if (z->message) return(z->message);
266  return("");
267}
268
269int owl_zwrite_is_message_set(owl_zwrite *z)
270{
271  if (z->message) return(1);
272  return(0);
273}
274
275int owl_zwrite_send_message(owl_zwrite *z)
276{
277  int i, j;
278  char *to = NULL;
279
280  if (z->message==NULL) return(-1);
281
282  j=owl_list_get_size(&(z->recips));
283  if (j>0) {
284    for (i=0; i<j; i++) {
285      if (strcmp(z->realm, "")) {
286        to = owl_sprintf("%s@%s", (char *) owl_list_get_element(&(z->recips), i), z->realm);
287      } else {
288        to = owl_strdup( owl_list_get_element(&(z->recips), i));
289      }
290      send_zephyr(z->opcode, z->zsig, z->class, z->inst, to, z->message);
291      owl_free(to);
292      to = NULL;
293    }
294  } else {
295    to = owl_sprintf( "@%s", z->realm);
296    send_zephyr(z->opcode, z->zsig, z->class, z->inst, to, z->message);
297  }
298  owl_free(to);
299  return(0);
300}
301
302int owl_zwrite_create_and_send_from_line(char *cmd, char *msg)
303{
304  owl_zwrite z;
305  int rv;
306  rv=owl_zwrite_create_from_line(&z, cmd);
307  if (rv) return(rv);
308  if (!owl_zwrite_is_message_set(&z)) {
309    owl_zwrite_set_message(&z, msg);
310  }
311  owl_zwrite_populate_zsig(&z);
312  owl_zwrite_send_message(&z);
313  owl_zwrite_free(&z);
314  return(0);
315}
316
317char *owl_zwrite_get_class(owl_zwrite *z)
318{
319  return(z->class);
320}
321
322char *owl_zwrite_get_instance(owl_zwrite *z)
323{
324  return(z->inst);
325}
326
327char *owl_zwrite_get_opcode(owl_zwrite *z)
328{
329  return(z->opcode);
330}
331
332void owl_zwrite_set_opcode(owl_zwrite *z, char *opcode)
333{
334  if (z->opcode) owl_free(z->opcode);
335  z->opcode=owl_validate_utf8(opcode);
336}
337
338char *owl_zwrite_get_realm(owl_zwrite *z)
339{
340  return(z->realm);
341}
342
343char *owl_zwrite_get_zsig(owl_zwrite *z)
344{
345  if (z->zsig) return(z->zsig);
346  return("");
347}
348
349void owl_zwrite_get_recipstr(owl_zwrite *z, char *buff)
350{
351  int i, j;
352
353  strcpy(buff, "");
354  j=owl_list_get_size(&(z->recips));
355  for (i=0; i<j; i++) {
356    strcat(buff, owl_list_get_element(&(z->recips), i));
357    strcat(buff, " ");
358  }
359  buff[strlen(buff)-1]='\0';
360}
361
362int owl_zwrite_get_numrecips(owl_zwrite *z)
363{
364  return(owl_list_get_size(&(z->recips)));
365}
366
367char *owl_zwrite_get_recip_n(owl_zwrite *z, int n)
368{
369  return(owl_list_get_element(&(z->recips), n));
370}
371
372int owl_zwrite_is_personal(owl_zwrite *z)
373{
374  /* return true if at least one of the recipients is personal */
375  int i, j;
376  char *foo;
377
378  j=owl_list_get_size(&(z->recips));
379  for (i=0; i<j; i++) {
380    foo=owl_list_get_element(&(z->recips), i);
381    if (foo[0]!='@') return(1);
382  }
383  return(0);
384}
385
386void owl_zwrite_free(owl_zwrite *z)
387{
388  owl_list_free_all(&(z->recips), &owl_free);
389  if (z->class) owl_free(z->class);
390  if (z->inst) owl_free(z->inst);
391  if (z->opcode) owl_free(z->opcode);
392  if (z->realm) owl_free(z->realm);
393  if (z->message) owl_free(z->message);
394  if (z->zsig) owl_free(z->zsig);
395}
Note: See TracBrowser for help on using the repository browser.