source: zwrite.c @ 6329cd5

release-1.9
Last change on this file since 6329cd5 was 6329cd5, checked in by David Benjamin <davidben@mit.edu>, 10 years ago
Allow building a zwrite from an argv Add new versions of owl_zwrite_create and owl_zwrite_new. Note that this means we rebuild z->zwriteline from scratch unconditionally. The only behavior change is that the user's spacing and quoting is not preserved in zwrite locktext. For instance :zwrite davidben -i "spaces yay?" now gets a locktext of ----> zwrite davidben -i 'spaces yay?' I think this isn't a big deal. It already happens for every other *write locktext, and if we kill the buff argument, it'll happen there too.
  • Property mode set to 100644
File size: 9.2 KB
Line 
1#include "owl.h"
2
3CALLER_OWN owl_zwrite *owl_zwrite_new_from_line(const char *line)
4{
5  owl_zwrite *z = g_new(owl_zwrite, 1);
6  if (owl_zwrite_create_from_line(z, line) < 0) {
7    owl_zwrite_delete(z);
8    return NULL;
9  }
10  return z;
11}
12
13CALLER_OWN owl_zwrite *owl_zwrite_new(int argc, const char *const *argv)
14{
15  owl_zwrite *z = g_new(owl_zwrite, 1);
16  if (owl_zwrite_create(z, argc, argv) < 0) {
17    owl_zwrite_delete(z);
18    return NULL;
19  }
20  return z;
21}
22
23G_GNUC_WARN_UNUSED_RESULT int owl_zwrite_create_from_line(owl_zwrite *z, const char *line)
24{
25  int argc;
26  char **argv;
27  int ret;
28
29  /* parse the command line for options */
30  argv = owl_parseline(line, &argc);
31  if (argc < 0) {
32    owl_function_error("Unbalanced quotes in zwrite");
33    return -1;
34  }
35  ret = owl_zwrite_create(z, argc, strs(argv));
36  g_strfreev(argv);
37  return ret;
38}
39
40G_GNUC_WARN_UNUSED_RESULT int owl_zwrite_create(owl_zwrite *z, int argc, const char *const *argv)
41{
42  int badargs = 0;
43  char *msg = NULL;
44 
45  /* start with null entries */
46  z->cmd=NULL;
47  z->realm=NULL;
48  z->class=NULL;
49  z->inst=NULL;
50  z->opcode=NULL;
51  z->zsig=NULL;
52  z->message=NULL;
53  z->cc=0;
54  z->noping=0;
55  z->recips = g_ptr_array_new();
56  z->zwriteline = owl_argv_quote(argc, argv);
57
58  if (argc && *(argv[0])!='-') {
59    z->cmd=g_strdup(argv[0]);
60    argc--;
61    argv++;
62  }
63  while (argc) {
64    if (!strcmp(argv[0], "-c")) {
65      if (argc<2) {
66        badargs=1;
67        break;
68      }
69      z->class=owl_validate_utf8(argv[1]);
70      argv+=2;
71      argc-=2;
72    } else if (!strcmp(argv[0], "-i")) {
73      if (argc<2) {
74        badargs=1;
75        break;
76      }
77      z->inst=owl_validate_utf8(argv[1]);
78      argv+=2;
79      argc-=2;
80    } else if (!strcmp(argv[0], "-r")) {
81      if (argc<2) {
82        badargs=1;
83        break;
84      }
85      z->realm=owl_validate_utf8(argv[1]);
86      argv+=2;
87      argc-=2;
88    } else if (!strcmp(argv[0], "-s")) {
89      if (argc<2) {
90        badargs=1;
91        break;
92      }
93      z->zsig=owl_validate_utf8(argv[1]);
94      argv+=2;
95      argc-=2;
96    } else if (!strcmp(argv[0], "-O")) {
97      if (argc<2) {
98        badargs=1;
99        break;
100      }
101      z->opcode=owl_validate_utf8(argv[1]);
102      argv+=2;
103      argc-=2;
104    } else if (!strcmp(argv[0], "-m")) {
105      if (argc<2) {
106        badargs=1;
107        break;
108      }
109      /* we must already have users or a class or an instance */
110      if (z->recips->len < 1 && (!z->class) && (!z->inst)) {
111        badargs=1;
112        break;
113      }
114
115      /* Once we have -m, gobble up everything else on the line */
116      argv++;
117      argc--;
118      msg = g_strjoinv(" ", (char**)argv);
119      break;
120    } else if (!strcmp(argv[0], "-C")) {
121      z->cc=1;
122      argv++;
123      argc--;
124    } else if (!strcmp(argv[0], "-n")) {
125      z->noping=1;
126      argv++;
127      argc--;
128    } else {
129      /* anything unattached is a recipient */
130      g_ptr_array_add(z->recips, owl_validate_utf8(argv[0]));
131      argv++;
132      argc--;
133    }
134  }
135
136  if (badargs) {
137    return(-1);
138  }
139
140  if (z->class == NULL &&
141      z->inst == NULL &&
142      z->recips->len == 0) {
143    owl_function_error("You must specify a recipient for zwrite");
144    return(-1);
145  }
146
147  /* now deal with defaults */
148  if (z->class==NULL) z->class=g_strdup("message");
149  if (z->inst==NULL) z->inst=g_strdup("personal");
150  if (z->realm==NULL) z->realm=g_strdup("");
151  if (z->opcode==NULL) z->opcode=g_strdup("");
152  /* z->message is allowed to stay NULL */
153
154  if(msg) {
155    owl_zwrite_set_message(z, msg);
156    g_free(msg);
157  }
158
159  return(0);
160}
161
162void owl_zwrite_populate_zsig(owl_zwrite *z)
163{
164  /* get a zsig, if not given */
165  if (z->zsig != NULL)
166    return;
167
168  z->zsig = owl_perlconfig_execute(owl_global_get_zsigfunc(&g));
169}
170
171void owl_zwrite_send_ping(const owl_zwrite *z)
172{
173  int i;
174  char *to;
175
176  if (z->noping) return;
177 
178  if (strcasecmp(z->class, "message")) {
179    return;
180  }
181
182  /* if there are no recipients we won't send a ping, which
183     is what we want */
184  for (i = 0; i < z->recips->len; i++) {
185    to = owl_zwrite_get_recip_n_with_realm(z, i);
186    send_ping(to, z->class, z->inst);
187    g_free(to);
188  }
189
190}
191
192/* Set the message with no post-processing*/
193void owl_zwrite_set_message_raw(owl_zwrite *z, const char *msg)
194{
195  g_free(z->message);
196  z->message = owl_validate_utf8(msg);
197}
198
199void owl_zwrite_set_message(owl_zwrite *z, const char *msg)
200{
201  int i;
202  GString *message;
203  char *tmp = NULL, *tmp2;
204
205  g_free(z->message);
206
207  if (z->recips->len > 0 && z->cc) {
208    message = g_string_new("CC: ");
209    for (i = 0; i < z->recips->len; i++) {
210      tmp = owl_zwrite_get_recip_n_with_realm(z, i);
211      g_string_append_printf(message, "%s ", tmp);
212      g_free(tmp);
213      tmp = NULL;
214    }
215    tmp = owl_validate_utf8(msg);
216    tmp2 = owl_text_expand_tabs(tmp);
217    g_string_append_printf(message, "\n%s", tmp2);
218    z->message = g_string_free(message, false);
219    g_free(tmp);
220    g_free(tmp2);
221  } else {
222    tmp=owl_validate_utf8(msg);
223    z->message=owl_text_expand_tabs(tmp);
224    g_free(tmp);
225  }
226}
227
228const char *owl_zwrite_get_message(const owl_zwrite *z)
229{
230  if (z->message) return(z->message);
231  return("");
232}
233
234int owl_zwrite_is_message_set(const owl_zwrite *z)
235{
236  if (z->message) return(1);
237  return(0);
238}
239
240int owl_zwrite_send_message(const owl_zwrite *z)
241{
242  int i, ret = 0;
243  char *to = NULL;
244
245  if (z->message==NULL) return(-1);
246
247  if (z->recips->len > 0) {
248    for (i = 0; i < z->recips->len; i++) {
249      to = owl_zwrite_get_recip_n_with_realm(z, i);
250      ret = send_zephyr(z->opcode, z->zsig, z->class, z->inst, to, z->message);
251      /* Abort on the first error, to match the zwrite binary. */
252      if (ret != 0)
253        break;
254      g_free(to);
255      to = NULL;
256    }
257  } else {
258    to = g_strdup_printf( "@%s", z->realm);
259    ret = send_zephyr(z->opcode, z->zsig, z->class, z->inst, to, z->message);
260  }
261  g_free(to);
262  return ret;
263}
264
265int owl_zwrite_create_and_send_from_line(const char *cmd, const char *msg)
266{
267  owl_zwrite z;
268  int rv;
269  rv=owl_zwrite_create_from_line(&z, cmd);
270  if (rv) return(rv);
271  if (!owl_zwrite_is_message_set(&z)) {
272    owl_zwrite_set_message(&z, msg);
273  }
274  owl_zwrite_populate_zsig(&z);
275  owl_zwrite_send_message(&z);
276  owl_zwrite_cleanup(&z);
277  return(0);
278}
279
280const char *owl_zwrite_get_class(const owl_zwrite *z)
281{
282  return(z->class);
283}
284
285const char *owl_zwrite_get_instance(const owl_zwrite *z)
286{
287  return(z->inst);
288}
289
290const char *owl_zwrite_get_opcode(const owl_zwrite *z)
291{
292  return(z->opcode);
293}
294
295void owl_zwrite_set_opcode(owl_zwrite *z, const char *opcode)
296{
297  g_free(z->opcode);
298  z->opcode=owl_validate_utf8(opcode);
299}
300
301const char *owl_zwrite_get_realm(const owl_zwrite *z)
302{
303  return(z->realm);
304}
305
306const char *owl_zwrite_get_zsig(const owl_zwrite *z)
307{
308  if (z->zsig) return(z->zsig);
309  return("");
310}
311
312void owl_zwrite_set_zsig(owl_zwrite *z, const char *zsig)
313{
314  g_free(z->zsig);
315  z->zsig = g_strdup(zsig);
316}
317
318int owl_zwrite_get_numrecips(const owl_zwrite *z)
319{
320  return z->recips->len;
321}
322
323const char *owl_zwrite_get_recip_n(const owl_zwrite *z, int n)
324{
325  return z->recips->pdata[n];
326}
327
328/* Caller must free the result. */
329CALLER_OWN char *owl_zwrite_get_recip_n_with_realm(const owl_zwrite *z, int n)
330{
331  if (z->realm[0]) {
332    return g_strdup_printf("%s@%s", owl_zwrite_get_recip_n(z, n), z->realm);
333  } else {
334    return g_strdup(owl_zwrite_get_recip_n(z, n));
335  }
336}
337
338int owl_zwrite_is_personal(const owl_zwrite *z)
339{
340  /* return true if at least one of the recipients is personal */
341  int i;
342  char *recip;
343
344  for (i = 0; i < z->recips->len; i++) {
345    recip = z->recips->pdata[i];
346    if (recip[0] != '@') return 1;
347  }
348  return(0);
349}
350
351void owl_zwrite_delete(owl_zwrite *z)
352{
353  owl_zwrite_cleanup(z);
354  g_free(z);
355}
356
357void owl_zwrite_cleanup(owl_zwrite *z)
358{
359  owl_ptr_array_free(z->recips, g_free);
360  g_free(z->cmd);
361  g_free(z->zwriteline);
362  g_free(z->class);
363  g_free(z->inst);
364  g_free(z->opcode);
365  g_free(z->realm);
366  g_free(z->message);
367  g_free(z->zsig);
368}
369
370/*
371 * Returns a zwrite line suitable for replying, specifically the
372 * message field is stripped out. Result should be freed with
373 * g_free.
374 *
375 * If not a CC, only the recip_index'th user will be replied to.
376 */
377CALLER_OWN char *owl_zwrite_get_replyline(const owl_zwrite *z, int recip_index)
378{
379  /* Match ordering in zwrite help. */
380  GString *buf = g_string_new("");
381  int i;
382
383  /* Disturbingly, it is apparently possible to z->cmd to be null if
384   * owl_zwrite_create_from_line got something starting with -. And we
385   * can't kill it because this is exported to perl. */
386  owl_string_append_quoted_arg(buf, z->cmd ? z->cmd : "zwrite");
387  if (z->noping) {
388    g_string_append(buf, " -n");
389  }
390  if (z->cc) {
391    g_string_append(buf, " -C");
392  }
393  if (strcmp(z->class, "message")) {
394    g_string_append(buf, " -c ");
395    owl_string_append_quoted_arg(buf, z->class);
396  }
397  if (strcmp(z->inst, "personal")) {
398    g_string_append(buf, " -i ");
399    owl_string_append_quoted_arg(buf, z->inst);
400  }
401  if (z->realm && z->realm[0] != '\0') {
402    g_string_append(buf, " -r ");
403    owl_string_append_quoted_arg(buf, z->realm);
404  }
405  if (z->opcode && z->opcode[0] != '\0') {
406    g_string_append(buf, " -O ");
407    owl_string_append_quoted_arg(buf, z->opcode);
408  }
409  if (z->cc) {
410    for (i = 0; i < z->recips->len; i++) {
411      g_string_append_c(buf, ' ');
412      owl_string_append_quoted_arg(buf, z->recips->pdata[i]);
413    }
414  } else if (recip_index < z->recips->len) {
415    g_string_append_c(buf, ' ');
416    owl_string_append_quoted_arg(buf, z->recips->pdata[recip_index]);
417  }
418
419  return g_string_free(buf, false);
420}
Note: See TracBrowser for help on using the repository browser.