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