358efc17ad78cfa6e91058591708e4b73bf76a5d
[gpgme.git] / src / engine-g13.c
1 /* engine-g13.c - G13 engine.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2009 g10 Code GmbH
4  
5    This file is part of GPGME.
6
7    GPGME is free software; you can redistribute it and/or modify it
8    under the terms of the GNU Lesser General Public License as
9    published by the Free Software Foundation; either version 2.1 of
10    the License, or (at your option) any later version.
11    
12    GPGME is distributed in the hope that it will be useful, but
13    WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Lesser General Public License for more details.
16    
17    You should have received a copy of the GNU Lesser General Public
18    License along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
21
22 #if HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <stdlib.h>
27 #include <string.h>
28 #include <sys/types.h>
29 #include <assert.h>
30 #include <unistd.h>
31 #include <locale.h>
32 #include <fcntl.h> /* FIXME */
33 #include <errno.h>
34
35 #include "gpgme.h"
36 #include "util.h"
37 #include "ops.h"
38 #include "wait.h"
39 #include "priv-io.h"
40 #include "sema.h"
41
42 #include "assuan.h"
43 #include "debug.h"
44
45 #include "engine-backend.h"
46
47 \f
48 typedef struct
49 {
50   int fd;       /* FD we talk about.  */
51   int server_fd;/* Server FD for this connection.  */
52   int dir;      /* Inbound/Outbound, maybe given implicit?  */
53   void *data;   /* Handler-specific data.  */
54   void *tag;    /* ID from the user for gpgme_remove_io_callback.  */
55   char server_fd_str[15]; /* Same as SERVER_FD but as a string.  We
56                              need this because _gpgme_io_fd2str can't
57                              be used on a closed descriptor.  */
58 } iocb_data_t;
59
60
61 struct engine_g13
62 {
63   assuan_context_t assuan_ctx;
64
65   int lc_ctype_set;
66   int lc_messages_set;
67
68   iocb_data_t status_cb;
69
70   struct gpgme_io_cbs io_cbs;
71
72   /* Internal callbacks.  */
73   engine_assuan_result_cb_t result_cb;
74   void *result_cb_value; 
75
76   /* User provided callbacks.  */
77   struct {
78     gpgme_assuan_data_cb_t data_cb;
79     void *data_cb_value;
80
81     gpgme_assuan_inquire_cb_t inq_cb;
82     void *inq_cb_value;
83
84     gpgme_assuan_status_cb_t status_cb;
85     void *status_cb_value;
86   } user;
87 };
88
89 typedef struct engine_g13 *engine_g13_t;
90
91
92 static void g13_io_event (void *engine, 
93                             gpgme_event_io_t type, void *type_data);
94
95
96 \f
97 static char *
98 g13_get_version (const char *file_name)
99 {
100   return _gpgme_get_program_version (file_name ? file_name
101                                      : _gpgme_get_g13_path ());
102 }
103
104
105 static const char *
106 g13_get_req_version (void)
107 {
108   return NEED_G13_VERSION;
109 }
110
111 \f
112 static void
113 close_notify_handler (int fd, void *opaque)
114 {
115   engine_g13_t g13 = opaque;
116
117   assert (fd != -1);
118   if (g13->status_cb.fd == fd)
119     {
120       if (g13->status_cb.tag)
121         (*g13->io_cbs.remove) (g13->status_cb.tag);
122       g13->status_cb.fd = -1;
123       g13->status_cb.tag = NULL;
124     }
125 }
126
127
128 /* This is the default inquiry callback.  We use it to handle the
129    Pinentry notifications.  */
130 static gpgme_error_t
131 default_inq_cb (engine_g13_t g13, const char *keyword, const char *args)
132 {
133   gpg_error_t err;
134
135   if (!strcmp (keyword, "PINENTRY_LAUNCHED"))
136     {
137       _gpgme_allow_set_foreground_window ((pid_t)strtoul (args, NULL, 10));
138     }
139
140   if (g13->user.inq_cb)
141     {
142       gpgme_data_t data = NULL;
143
144       err = g13->user.inq_cb (g13->user.inq_cb_value,
145                                 keyword, args, &data);
146       if (!err && data)
147         {
148           /* FIXME: Returning data is not yet implemented.  However we
149              need to allow the caller to cleanup his data object.
150              Thus we run the callback in finish mode immediately.  */
151           err = g13->user.inq_cb (g13->user.inq_cb_value,
152                                   NULL, NULL, &data);
153         }
154     }
155   else
156     err = 0;
157
158   return err;
159 }
160
161
162 static gpgme_error_t
163 g13_cancel (void *engine)
164 {
165   engine_g13_t g13 = engine;
166
167   if (!g13)
168     return gpg_error (GPG_ERR_INV_VALUE);
169
170   if (g13->status_cb.fd != -1)
171     _gpgme_io_close (g13->status_cb.fd);
172
173   if (g13->assuan_ctx)
174     {
175       assuan_release (g13->assuan_ctx);
176       g13->assuan_ctx = NULL;
177     }
178
179   return 0;
180 }
181
182
183 static gpgme_error_t
184 g13_cancel_op (void *engine)
185 {
186   engine_g13_t g13 = engine;
187
188   if (!g13)
189     return gpg_error (GPG_ERR_INV_VALUE);
190
191   if (g13->status_cb.fd != -1)
192     _gpgme_io_close (g13->status_cb.fd);
193
194   return 0;
195 }
196
197
198 static void
199 g13_release (void *engine)
200 {
201   engine_g13_t g13 = engine;
202
203   if (!g13)
204     return;
205
206   g13_cancel (engine);
207
208   free (g13);
209 }
210
211
212 static gpgme_error_t
213 g13_new (void **engine, const char *file_name, const char *home_dir)
214 {
215   gpgme_error_t err = 0;
216   engine_g13_t g13;
217   int argc;
218   char *argv[5];
219   char *dft_display = NULL;
220   char dft_ttyname[64];
221   char *dft_ttytype = NULL;
222   char *optstr;
223
224   g13 = calloc (1, sizeof *g13);
225   if (!g13)
226     return gpg_error_from_errno (errno);
227
228   g13->status_cb.fd = -1;
229   g13->status_cb.dir = 1;
230   g13->status_cb.tag = 0;
231   g13->status_cb.data = g13;
232
233   err = assuan_new (&g13->assuan_ctx);
234   if (err)
235     goto leave;
236
237   argc = 0;
238   argv[argc++] = "g13";
239   if (home_dir)
240     {
241       argv[argc++] = "--homedir";
242       argv[argc++] = home_dir;
243     }
244   argv[argc++] = "--server";
245   argv[argc++] = NULL;
246
247   err = assuan_new_ext (&g13->assuan_ctx, GPG_ERR_SOURCE_GPGME,
248                         &_gpgme_assuan_malloc_hooks, _gpgme_assuan_log_cb,
249                         NULL);
250   if (err)
251     goto leave;
252   assuan_ctx_set_system_hooks (g13->assuan_ctx, &_gpgme_assuan_system_hooks);
253
254 #if USE_DESCRIPTOR_PASSING
255   err = assuan_pipe_connect_ext
256     (g13->assuan_ctx, file_name ? file_name : _gpgme_get_g13_path (),
257      argv, NULL, NULL, NULL, 1);
258 #else
259   err = assuan_pipe_connect
260     (g13->assuan_ctx, file_name ? file_name : _gpgme_get_g13_path (),
261      argv, NULL);
262 #endif
263   if (err)
264     goto leave;
265
266   err = _gpgme_getenv ("DISPLAY", &dft_display);
267   if (err)
268     goto leave;
269   if (dft_display)
270     {
271       if (asprintf (&optstr, "OPTION display=%s", dft_display) < 0)
272         {
273           free (dft_display);
274           err = gpg_error_from_errno (errno);
275           goto leave;
276         }
277       free (dft_display);
278
279       err = assuan_transact (g13->assuan_ctx, optstr, NULL, NULL, NULL,
280                              NULL, NULL, NULL);
281       free (optstr);
282       if (err)
283         goto leave;
284     }
285
286   if (isatty (1))
287     {
288       int rc;
289
290       rc = ttyname_r (1, dft_ttyname, sizeof (dft_ttyname));
291       if (rc)
292         {
293           err = gpg_error_from_errno (rc);
294           goto leave;
295         }
296       else
297         {
298           if (asprintf (&optstr, "OPTION ttyname=%s", dft_ttyname) < 0)
299             {
300               err = gpg_error_from_errno (errno);
301               goto leave;
302             }
303           err = assuan_transact (g13->assuan_ctx, optstr, NULL, NULL, NULL,
304                                  NULL, NULL, NULL);
305           free (optstr);
306           if (err)
307             goto leave;
308
309           err = _gpgme_getenv ("TERM", &dft_ttytype);
310           if (err)
311             goto leave;
312           if (dft_ttytype)
313             {
314               if (asprintf (&optstr, "OPTION ttytype=%s", dft_ttytype) < 0)
315                 {
316                   free (dft_ttytype);
317                   err = gpg_error_from_errno (errno);
318                   goto leave;
319                 }
320               free (dft_ttytype);
321
322               err = assuan_transact (g13->assuan_ctx, optstr, NULL, NULL,
323                                      NULL, NULL, NULL, NULL);
324               free (optstr);
325               if (err)
326                 goto leave;
327             }
328         }
329     }
330
331 #ifdef HAVE_W32_SYSTEM
332   /* Under Windows we need to use AllowSetForegroundWindow.  Tell
333      g13 to tell us when it needs it.  */
334   if (!err)
335     {
336       err = assuan_transact (g13->assuan_ctx, "OPTION allow-pinentry-notify",
337                              NULL, NULL, NULL, NULL, NULL, NULL);
338       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)
339         err = 0; /* This is a new feature of g13.  */
340     }
341 #endif /*HAVE_W32_SYSTEM*/
342
343  leave:
344
345   if (err)
346     g13_release (g13);
347   else
348     *engine = g13;
349
350   return err;
351 }
352
353
354 static gpgme_error_t
355 g13_set_locale (void *engine, int category, const char *value)
356 {
357   engine_g13_t g13 = engine;
358   gpgme_error_t err;
359   char *optstr;
360   char *catstr;
361
362   /* FIXME: If value is NULL, we need to reset the option to default.
363      But we can't do this.  So we error out here.  G13 needs support
364      for this.  */
365   if (category == LC_CTYPE)
366     {
367       catstr = "lc-ctype";
368       if (!value && g13->lc_ctype_set)
369         return gpg_error (GPG_ERR_INV_VALUE);
370       if (value)
371         g13->lc_ctype_set = 1;
372     }
373 #ifdef LC_MESSAGES
374   else if (category == LC_MESSAGES)
375     {
376       catstr = "lc-messages";
377       if (!value && g13->lc_messages_set)
378         return gpg_error (GPG_ERR_INV_VALUE);
379       if (value)
380         g13->lc_messages_set = 1;
381     }
382 #endif /* LC_MESSAGES */
383   else
384     return gpg_error (GPG_ERR_INV_VALUE);
385
386   /* FIXME: Reset value to default.  */
387   if (!value) 
388     return 0;
389
390   if (asprintf (&optstr, "OPTION %s=%s", catstr, value) < 0)
391     err = gpg_error_from_errno (errno);
392   else
393     {
394       err = assuan_transact (g13->assuan_ctx, optstr, NULL, NULL,
395                              NULL, NULL, NULL, NULL);
396       free (optstr);
397     }
398
399   return err;
400 }
401
402
403 static gpgme_error_t
404 g13_assuan_simple_command (assuan_context_t ctx, char *cmd,
405                              engine_status_handler_t status_fnc,
406                              void *status_fnc_value)
407 {
408   gpg_error_t err;
409   char *line;
410   size_t linelen;
411
412   err = assuan_write_line (ctx, cmd);
413   if (err)
414     return err;
415
416   do
417     {
418       err = assuan_read_line (ctx, &line, &linelen);
419       if (err)
420         return err;
421
422       if (*line == '#' || !linelen)
423         continue;
424
425       if (linelen >= 2
426           && line[0] == 'O' && line[1] == 'K'
427           && (line[2] == '\0' || line[2] == ' '))
428         return 0;
429       else if (linelen >= 4
430           && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
431           && line[3] == ' ')
432         err = atoi (&line[4]);
433       else if (linelen >= 2
434                && line[0] == 'S' && line[1] == ' ')
435         {
436           char *rest;
437
438           rest = strchr (line + 2, ' ');
439           if (!rest)
440             rest = line + linelen; /* set to an empty string */
441           else
442             *(rest++) = 0;
443
444           /* Nothing to do with status lines.  */
445         }
446       else
447         err = gpg_error (GPG_ERR_GENERAL);
448     }
449   while (!err);
450
451   return err;
452 }
453
454
455 static gpgme_error_t
456 status_handler (void *opaque, int fd)
457 {
458   struct io_cb_data *data = (struct io_cb_data *) opaque;
459   engine_g13_t g13 = (engine_g13_t) data->handler_value;
460   gpgme_error_t err = 0;
461   char *line;
462   size_t linelen;
463
464   do
465     {
466       err = assuan_read_line (g13->assuan_ctx, &line, &linelen);
467       if (err)
468         {
469           /* Try our best to terminate the connection friendly.  */
470           /*      assuan_write_line (g13->assuan_ctx, "BYE"); */
471           TRACE2 (DEBUG_CTX, "gpgme:status_handler", g13,
472                   "fd 0x%x: error reading assuan line: %s",
473                   fd, gpg_strerror (err));
474         }
475       else if (linelen >= 3
476                && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
477                && (line[3] == '\0' || line[3] == ' '))
478         {
479           if (line[3] == ' ')
480             err = atoi (&line[4]);
481           if (! err)
482             err = gpg_error (GPG_ERR_GENERAL);
483           TRACE2 (DEBUG_CTX, "gpgme:status_handler", g13,
484                   "fd 0x%x: ERR line: %s",
485                   fd, err ? gpg_strerror (err) : "ok");
486           
487           /* In g13, command execution errors are not fatal, as we use
488              a session based protocol.  */
489           if (g13->result_cb)
490             err = g13->result_cb (g13->result_cb_value, err);
491           else
492             err = 0;
493           if (!err)
494             {
495               _gpgme_io_close (g13->status_cb.fd);
496               return 0;
497             }
498         }
499       else if (linelen >= 2
500                && line[0] == 'O' && line[1] == 'K'
501                && (line[2] == '\0' || line[2] == ' '))
502         {
503           TRACE1 (DEBUG_CTX, "gpgme:status_handler", g13,
504                   "fd 0x%x: OK line", fd);
505           if (g13->result_cb)
506             err = g13->result_cb (g13->result_cb_value, 0);
507           else
508             err = 0;
509           if (!err)
510             {
511               _gpgme_io_close (g13->status_cb.fd);
512               return 0;
513             }
514         }
515       else if (linelen > 2
516                && line[0] == 'D' && line[1] == ' ')
517         {
518           /* We are using the colon handler even for plain inline data
519              - strange name for that function but for historic reasons
520              we keep it.  */
521           /* FIXME We can't use this for binary data because we
522              assume this is a string.  For the current usage of colon
523              output it is correct.  */
524           char *src = line + 2;
525           char *end = line + linelen;
526           char *dst = src;
527
528           linelen = 0;
529           while (src < end)
530             {
531               if (*src == '%' && src + 2 < end)
532                 {
533                   /* Handle escaped characters.  */
534                   ++src;
535                   *dst++ = _gpgme_hextobyte (src);
536                   src += 2;
537                 }
538               else
539                 *dst++ = *src++;
540
541               linelen++;
542             }
543
544           src = line + 2;
545           if (linelen && g13->user.data_cb)
546             err = g13->user.data_cb (g13->user.data_cb_value,
547                                        src, linelen);
548           else
549             err = 0;
550
551           TRACE2 (DEBUG_CTX, "gpgme:g13_status_handler", g13,
552                   "fd 0x%x: D inlinedata; status from cb: %s",
553                   fd, (g13->user.data_cb ?
554                        (err? gpg_strerror (err):"ok"):"no callback"));
555
556         }
557       else if (linelen > 2
558                && line[0] == 'S' && line[1] == ' ')
559         {
560           char *src;
561           char *args;
562
563           src = line + 2;
564           while (*src == ' ')
565             src++;
566           
567           args = strchr (line + 2, ' ');
568           if (!args)
569             args = line + linelen; /* set to an empty string */
570           else
571             *(args++) = 0;
572
573           while (*args == ' ')
574             args++;
575
576           if (g13->user.status_cb)
577             err = g13->user.status_cb (g13->user.status_cb_value,
578                                        src, args);
579           else
580             err = 0;
581
582           TRACE3 (DEBUG_CTX, "gpgme:g13_status_handler", g13,
583                   "fd 0x%x: S line (%s) - status from cb: %s",
584                   fd, line+2, (g13->user.status_cb ?
585                                (err? gpg_strerror (err):"ok"):"no callback"));
586         }
587       else if (linelen >= 7
588                && line[0] == 'I' && line[1] == 'N' && line[2] == 'Q'
589                && line[3] == 'U' && line[4] == 'I' && line[5] == 'R'
590                && line[6] == 'E' 
591                && (line[7] == '\0' || line[7] == ' '))
592         {
593           char *src;
594           char *args;
595           
596           for (src=line+7; *src == ' '; src++)
597             ;
598
599           args = strchr (src, ' ');
600           if (!args)
601             args = line + linelen; /* Let it point to an empty string.  */
602           else
603             *(args++) = 0;
604
605           while (*args == ' ')
606             args++;
607
608           err = default_inq_cb (g13, src, args);
609           if (!err) 
610             {
611               /* Flush and send END.  */
612               err = assuan_send_data (g13->assuan_ctx, NULL, 0);
613             }
614           else if (gpg_err_code (err) == GPG_ERR_ASS_CANCELED)
615             {
616               /* Flush and send CANcel.  */
617               err = assuan_send_data (g13->assuan_ctx, NULL, 1);
618             }
619           assuan_write_line (g13->assuan_ctx, "END");
620         }
621     }
622   while (!err && assuan_pending_line (g13->assuan_ctx));
623   
624   return err;
625 }
626   
627
628 static gpgme_error_t
629 add_io_cb (engine_g13_t g13, iocb_data_t *iocbd, gpgme_io_cb_t handler)
630 {
631   gpgme_error_t err;
632
633   TRACE_BEG2 (DEBUG_ENGINE, "engine-g13:add_io_cb", g13,
634               "fd %d, dir %d", iocbd->fd, iocbd->dir);
635   err = (*g13->io_cbs.add) (g13->io_cbs.add_priv,
636                               iocbd->fd, iocbd->dir,
637                               handler, iocbd->data, &iocbd->tag);
638   if (err)
639     return TRACE_ERR (err);
640   if (!iocbd->dir)
641     /* FIXME Kludge around poll() problem.  */
642     err = _gpgme_io_set_nonblocking (iocbd->fd);
643   return TRACE_ERR (err);
644 }
645
646
647 static gpgme_error_t
648 start (engine_g13_t g13, const char *command)
649 {
650   gpgme_error_t err;
651   int fdlist[5];
652   int nfds;
653
654   /* We need to know the fd used by assuan for reads.  We do this by
655      using the assumption that the first returned fd from
656      assuan_get_active_fds() is always this one.  */
657   nfds = assuan_get_active_fds (g13->assuan_ctx, 0 /* read fds */,
658                                 fdlist, DIM (fdlist));
659   if (nfds < 1)
660     return gpg_error (GPG_ERR_GENERAL); /* FIXME */
661
662   /* We "duplicate" the file descriptor, so we can close it here (we
663      can't close fdlist[0], as that is closed by libassuan, and
664      closing it here might cause libassuan to close some unrelated FD
665      later).  Alternatively, we could special case status_fd and
666      register/unregister it manually as needed, but this increases
667      code duplication and is more complicated as we can not use the
668      close notifications etc.  A third alternative would be to let
669      Assuan know that we closed the FD, but that complicates the
670      Assuan interface.  */
671
672   g13->status_cb.fd = _gpgme_io_dup (fdlist[0]);
673   if (g13->status_cb.fd < 0)
674     return gpg_error_from_syserror ();
675
676   if (_gpgme_io_set_close_notify (g13->status_cb.fd,
677                                   close_notify_handler, g13))
678     {
679       _gpgme_io_close (g13->status_cb.fd);
680       g13->status_cb.fd = -1;
681       return gpg_error (GPG_ERR_GENERAL);
682     }
683
684   err = add_io_cb (g13, &g13->status_cb, status_handler);
685   if (!err)
686     err = assuan_write_line (g13->assuan_ctx, command);
687
688   if (!err)
689     g13_io_event (g13, GPGME_EVENT_START, NULL);
690
691   return err;
692 }
693
694
695 #if USE_DESCRIPTOR_PASSING
696 static gpgme_error_t
697 g13_reset (void *engine)
698 {
699   engine_g13_t g13 = engine;
700
701   /* We must send a reset because we need to reset the list of
702      signers.  Note that RESET does not reset OPTION commands. */
703   return g13_assuan_simple_command (g13->assuan_ctx, "RESET", NULL, NULL);
704 }
705 #endif
706
707
708 static gpgme_error_t
709 g13_transact (void *engine,
710                 const char *command,
711                 engine_assuan_result_cb_t result_cb,
712                 void *result_cb_value,
713                 gpgme_assuan_data_cb_t data_cb,
714                 void *data_cb_value,
715                 gpgme_assuan_inquire_cb_t inq_cb,
716                 void *inq_cb_value,
717                 gpgme_assuan_status_cb_t status_cb,
718                 void *status_cb_value)
719 {
720   engine_g13_t g13 = engine;
721   gpgme_error_t err;
722
723   if (!g13 || !command || !*command)
724     return gpg_error (GPG_ERR_INV_VALUE);
725
726   g13->result_cb = result_cb;
727   g13->result_cb_value = result_cb_value;
728   g13->user.data_cb = data_cb;
729   g13->user.data_cb_value = data_cb_value;
730   g13->user.inq_cb = inq_cb;
731   g13->user.inq_cb_value = inq_cb_value;
732   g13->user.status_cb = status_cb;
733   g13->user.status_cb_value = status_cb_value;
734
735   err = start (g13, command);
736   return err;
737 }
738
739
740
741 static void
742 g13_set_io_cbs (void *engine, gpgme_io_cbs_t io_cbs)
743 {
744   engine_g13_t g13 = engine;
745   g13->io_cbs = *io_cbs;
746 }
747
748
749 static void
750 g13_io_event (void *engine, gpgme_event_io_t type, void *type_data)
751 {
752   engine_g13_t g13 = engine;
753
754   TRACE3 (DEBUG_ENGINE, "gpgme:g13_io_event", g13,
755           "event %p, type %d, type_data %p",
756           g13->io_cbs.event, type, type_data);
757   if (g13->io_cbs.event)
758     (*g13->io_cbs.event) (g13->io_cbs.event_priv, type, type_data);
759 }
760
761
762 struct engine_ops _gpgme_engine_ops_g13 =
763   {
764     /* Static functions.  */
765     _gpgme_get_g13_path,
766     NULL,
767     g13_get_version,
768     g13_get_req_version,
769     g13_new,
770
771     /* Member functions.  */
772     g13_release,
773 #if USE_DESCRIPTOR_PASSING
774     g13_reset,
775 #else
776     NULL,                       /* reset */
777 #endif
778     NULL,               /* set_status_handler */
779     NULL,               /* set_command_handler */
780     NULL,               /* set_colon_line_handler */
781     g13_set_locale,
782     NULL,               /* decrypt */
783     NULL,               /* delete */
784     NULL,               /* edit */
785     NULL,               /* encrypt */
786     NULL,               /* encrypt_sign */
787     NULL,               /* export */
788     NULL,               /* export_ext */
789     NULL,               /* genkey */
790     NULL,               /* import */
791     NULL,               /* keylist */
792     NULL,               /* keylist_ext */
793     NULL,               /* sign */
794     NULL,               /* trustlist */
795     NULL,               /* verify */
796     NULL,               /* getauditlog */
797     g13_transact,
798     NULL,               /* conf_load */
799     NULL,               /* conf_save */
800     g13_set_io_cbs,
801     g13_io_event,
802     g13_cancel,
803     g13_cancel_op,
804   };