Add asynchronous callback capability to the askappend() alert box.

This was harder than verify_ssh_host_key() and askalg() put
together, because:
 (a) askappend() can be called at any time, since it's a side effect
     of data-logging functions. Therefore there can be an unfinished
     askappend() alert at any time, and hence the OS X front end has
     to be prepared to _queue_ other alerts which occur during that
     time.
 (b) logging.c has to do something with data that comes in while
     it's waiting for an answer to askappend(). It buffers it until
     it knows what the user wants done with it. This involved
     something of a reorganisation of logging.c.

git-svn-id: svn://svn.tartarus.org/sgt/putty@5344 cda61777-01e9-0310-a592-d414129be87e

diff --git a/logging.c b/logging.c
index f1c42cd..a54b167 100644 (file)
--- a/logging.c
+++ b/logging.c
@@ -10,6 +10,8 @@
 /* log session to file stuff ... */
 struct LogContext {
     FILE *lgfp;
+    enum { CLOSED, OPENING, OPEN, ERROR } state;
+    bufchain queue;
     Filename currlogfilename;
     void *frontend;
     Config cfg;
@@ -18,20 +20,44 @@ struct LogContext {
 static void xlatlognam(Filename *d, Filename s, char *hostname, struct tm *tm);
 
 /*
- * Log session traffic.
+ * Internal wrapper function which must be called for _all_ output
+ * to the log file. It takes care of opening the log file if it
+ * isn't open, buffering data if it's in the process of being
+ * opened asynchronously, etc.
  */
-void logtraffic(void *handle, unsigned char c, int logmode)
+static void logwrite(struct LogContext *ctx, void *data, int len)
 {
-    struct LogContext *ctx = (struct LogContext *)handle;
-    if (ctx->cfg.logtype > 0) {
-       if (ctx->cfg.logtype == logmode) {
-           /* deferred open file from pgm start? */
-           if (!ctx->lgfp)
-               logfopen(ctx);
-           if (ctx->lgfp)
-               fputc(c, ctx->lgfp);
-       }
-    }
+    /*
+     * In state CLOSED, we call logfopen, which will set the state
+     * to one of OPENING, OPEN or ERROR. Hence we process all of
+     * those three _after_ processing CLOSED.
+     */
+    if (ctx->state == CLOSED)
+       logfopen(ctx);
+
+    if (ctx->state == OPENING) {
+       bufchain_add(&ctx->queue, data, len);
+    } else if (ctx->state == OPEN) {
+       assert(ctx->lgfp);
+       fwrite(data, 1, len, ctx->lgfp);
+    }                                 /* else ERROR, so ignore the write */
+}
+
+/*
+ * Convenience wrapper on logwrite() which printf-formats the
+ * string.
+ */
+static void logprintf(struct LogContext *ctx, const char *fmt, ...)
+{
+    va_list ap;
+    char *data;
+
+    va_start(ap, fmt);
+    data = dupvprintf(fmt, ap);
+    va_end(ap);
+
+    logwrite(ctx, data, strlen(data));
+    sfree(data);
 }
 
 /*
@@ -40,10 +66,123 @@ void logtraffic(void *handle, unsigned char c, int logmode)
 void logflush(void *handle) {
     struct LogContext *ctx = (struct LogContext *)handle;
     if (ctx->cfg.logtype > 0)
-       if (ctx->lgfp)
+       if (ctx->state == OPEN)
            fflush(ctx->lgfp);
 }
 
+static void logfopen_callback(void *handle, int mode)
+{
+    struct LogContext *ctx = (struct LogContext *)handle;
+    char buf[256], *event;
+    struct tm tm;
+    const char *fmode;
+
+    if (mode == 0) {
+       ctx->state = ERROR;            /* disable logging */
+    } else {
+       fmode = (mode == 1 ? "a" : "w");
+       ctx->lgfp = f_open(ctx->currlogfilename, fmode);
+       if (ctx->lgfp)
+           ctx->state = OPEN;
+       else
+           ctx->state = ERROR;
+    }
+
+    if (ctx->state == OPEN) {
+       /* Write header line into log file. */
+       tm = ltime();
+       strftime(buf, 24, "%Y.%m.%d %H:%M:%S", &tm);
+       logprintf(ctx, "=~=~=~=~=~=~=~=~=~=~=~= PuTTY log %s"
+                 " =~=~=~=~=~=~=~=~=~=~=~=\r\n", buf);
+    }
+
+    event = dupprintf("%s session log (%s mode) to file: %s",
+                     (mode == 0 ? "Disabled writing" :
+                       mode == 1 ? "Appending" : "Writing new"),
+                     (ctx->cfg.logtype == LGTYP_ASCII ? "ASCII" :
+                      ctx->cfg.logtype == LGTYP_DEBUG ? "raw" :
+                      ctx->cfg.logtype == LGTYP_PACKETS ? "SSH packets" :
+                      "unknown"),
+                     filename_to_str(&ctx->currlogfilename));
+    logevent(ctx->frontend, event);
+    sfree(event);
+
+    /*
+     * Having either succeeded or failed in opening the log file,
+     * we should write any queued data out.
+     */
+    assert(ctx->state != OPENING);     /* make _sure_ it won't be requeued */
+    while (bufchain_size(&ctx->queue)) {
+       void *data;
+       int len;
+       bufchain_prefix(&ctx->queue, &data, &len);
+       logwrite(ctx, data, len);
+       bufchain_consume(&ctx->queue, len);
+    }
+}
+
+/*
+ * Open the log file. Takes care of detecting an already-existing
+ * file and asking the user whether they want to append, overwrite
+ * or cancel logging.
+ */
+void logfopen(void *handle)
+{
+    struct LogContext *ctx = (struct LogContext *)handle;
+    struct tm tm;
+    int mode;
+
+    /* Prevent repeat calls */
+    if (ctx->state != CLOSED)
+       return;
+
+    if (!ctx->cfg.logtype)
+       return;
+
+    tm = ltime();
+
+    /* substitute special codes in file name */
+    xlatlognam(&ctx->currlogfilename, ctx->cfg.logfilename,ctx->cfg.host, &tm);
+
+    ctx->lgfp = f_open(ctx->currlogfilename, "r");  /* file already present? */
+    if (ctx->lgfp) {
+       fclose(ctx->lgfp);
+       if (ctx->cfg.logxfovr != LGXF_ASK) {
+           mode = ((ctx->cfg.logxfovr == LGXF_OVR) ? 2 : 1);
+       } else
+           mode = askappend(ctx->frontend, ctx->currlogfilename,
+                            logfopen_callback, ctx);
+    } else
+       mode = 2;                      /* create == overwrite */
+
+    if (mode < 0)
+       ctx->state = OPENING;
+    else
+       logfopen_callback(ctx, mode);  /* open the file */
+}
+
+void logfclose(void *handle)
+{
+    struct LogContext *ctx = (struct LogContext *)handle;
+    if (ctx->lgfp) {
+       fclose(ctx->lgfp);
+       ctx->lgfp = NULL;
+    }
+    ctx->state = CLOSED;
+}
+
+/*
+ * Log session traffic.
+ */
+void logtraffic(void *handle, unsigned char c, int logmode)
+{
+    struct LogContext *ctx = (struct LogContext *)handle;
+    if (ctx->cfg.logtype > 0) {
+       if (ctx->cfg.logtype == logmode)
+           logwrite(ctx, &c, 1);
+    }
+}
+
 /*
  * Log an Event Log entry. Used in SSH packet logging mode; this is
  * also as convenient a place as any to put the output of Event Log
@@ -62,10 +201,7 @@ void log_eventlog(void *handle, const char *event)
     }
     if (ctx->cfg.logtype != LGTYP_PACKETS)
        return;
-    if (!ctx->lgfp)
-       logfopen(ctx);
-    if (ctx->lgfp)
-       fprintf(ctx->lgfp, "Event Log: %s\r\n", event);
+    logprintf(ctx, "Event Log: %s\r\n", event);
 }
 
 /*
@@ -79,164 +215,95 @@ void log_packet(void *handle, int direction, int type,
 {
     struct LogContext *ctx = (struct LogContext *)handle;
     char dumpdata[80], smalldata[5];
+    int p = 0, b = 0, omitted = 0;
+    int output_pos = 0; /* NZ if pending output in dumpdata */
 
     if (ctx->cfg.logtype != LGTYP_PACKETS)
        return;
-    if (!ctx->lgfp)
-       logfopen(ctx);
-    if (ctx->lgfp) {
-       int p = 0, b = 0, omitted = 0;
-       int output_pos = 0; /* NZ if pending output in dumpdata */
-
-       /* Packet header. */
-       fprintf(ctx->lgfp, "%s packet type %d / 0x%02x (%s)\r\n",
-               direction == PKT_INCOMING ? "Incoming" : "Outgoing",
-               type, type, texttype);
-
-       /*
-        * Output a hex/ASCII dump of the packet body, blanking/omitting
-        * parts as specified.
-        */
-       while (p < len) {
-           int blktype;
-
-           /* Move to a current entry in the blanking array. */
-           while ((b < n_blanks) &&
-                  (p >= blanks[b].offset + blanks[b].len))
-               b++;
-           /* Work out what type of blanking to apply to
-            * this byte. */
-           blktype = PKTLOG_EMIT; /* default */
-           if ((b < n_blanks) &&
-               (p >= blanks[b].offset) &&
-               (p < blanks[b].offset + blanks[b].len))
-               blktype = blanks[b].type;
-
-           /* If we're about to stop omitting, it's time to say how
-            * much we omitted. */
-           if ((blktype != PKTLOG_OMIT) && omitted) {
-               fprintf(ctx->lgfp, "  (%d byte%s omitted)\r\n",
-                       omitted, (omitted==1?"":"s"));
-               omitted = 0;
-           }
 
-           /* (Re-)initialise dumpdata as necessary
-            * (start of row, or if we've just stopped omitting) */
-           if (!output_pos && !omitted)
-               sprintf(dumpdata, "  %08x%*s\r\n", p-(p%16), 1+3*16+2+16, "");
-
-           /* Deal with the current byte. */
-           if (blktype == PKTLOG_OMIT) {
-               omitted++;
-           } else {
-               int c;
-               if (blktype == PKTLOG_BLANK) {
-                   c = 'X';
-                   sprintf(smalldata, "XX");
-               } else {  /* PKTLOG_EMIT */
-                   c = ((unsigned char *)data)[p];
-                   sprintf(smalldata, "%02x", c);
-               }
-               dumpdata[10+2+3*(p%16)] = smalldata[0];
-               dumpdata[10+2+3*(p%16)+1] = smalldata[1];
-               dumpdata[10+1+3*16+2+(p%16)] = (isprint(c) ? c : '.');
-               output_pos = (p%16) + 1;
-           }
+    /* Packet header. */
+    logprintf(ctx, "%s packet type %d / 0x%02x (%s)\r\n",
+             direction == PKT_INCOMING ? "Incoming" : "Outgoing",
+             type, type, texttype);
+
+    /*
+     * Output a hex/ASCII dump of the packet body, blanking/omitting
+     * parts as specified.
+     */
+    while (p < len) {
+       int blktype;
+
+       /* Move to a current entry in the blanking array. */
+       while ((b < n_blanks) &&
+              (p >= blanks[b].offset + blanks[b].len))
+           b++;
+       /* Work out what type of blanking to apply to
+        * this byte. */
+       blktype = PKTLOG_EMIT; /* default */
+       if ((b < n_blanks) &&
+           (p >= blanks[b].offset) &&
+           (p < blanks[b].offset + blanks[b].len))
+           blktype = blanks[b].type;
+
+       /* If we're about to stop omitting, it's time to say how
+        * much we omitted. */
+       if ((blktype != PKTLOG_OMIT) && omitted) {
+           logprintf(ctx, "  (%d byte%s omitted)\r\n",
+                     omitted, (omitted==1?"":"s"));
+           omitted = 0;
+       }
 
-           p++;
+       /* (Re-)initialise dumpdata as necessary
+        * (start of row, or if we've just stopped omitting) */
+       if (!output_pos && !omitted)
+           sprintf(dumpdata, "  %08x%*s\r\n", p-(p%16), 1+3*16+2+16, "");
 
-           /* Flush row if necessary */
-           if (((p % 16) == 0) || (p == len) || omitted) {
-               if (output_pos) {
-                   strcpy(dumpdata + 10+1+3*16+2+output_pos, "\r\n");
-                   fputs(dumpdata, ctx->lgfp);
-                   output_pos = 0;
-               }
+       /* Deal with the current byte. */
+       if (blktype == PKTLOG_OMIT) {
+           omitted++;
+       } else {
+           int c;
+           if (blktype == PKTLOG_BLANK) {
+               c = 'X';
+               sprintf(smalldata, "XX");
+           } else {  /* PKTLOG_EMIT */
+               c = ((unsigned char *)data)[p];
+               sprintf(smalldata, "%02x", c);
            }
-
+           dumpdata[10+2+3*(p%16)] = smalldata[0];
+           dumpdata[10+2+3*(p%16)+1] = smalldata[1];
+           dumpdata[10+1+3*16+2+(p%16)] = (isprint(c) ? c : '.');
+           output_pos = (p%16) + 1;
        }
 
-       /* Tidy up */
-       if (omitted)
-           fprintf(ctx->lgfp, "  (%d byte%s omitted)\r\n",
-                   omitted, (omitted==1?"":"s"));
-       fflush(ctx->lgfp);
-    }
-}
-
-/* open log file append/overwrite mode */
-void logfopen(void *handle)
-{
-    struct LogContext *ctx = (struct LogContext *)handle;
-    char buf[256];
-    struct tm tm;
-    char writemod[4];
-
-    /* Prevent repeat calls */
-    if (ctx->lgfp)
-       return;
-
-    if (!ctx->cfg.logtype)
-       return;
-    sprintf(writemod, "wb");          /* default to rewrite */
+       p++;
 
-    tm = ltime();
-
-    /* substitute special codes in file name */
-    xlatlognam(&ctx->currlogfilename, ctx->cfg.logfilename,ctx->cfg.host, &tm);
-
-    ctx->lgfp = f_open(ctx->currlogfilename, "r");  /* file already present? */
-    if (ctx->lgfp) {
-       int i;
-       fclose(ctx->lgfp);
-       if (ctx->cfg.logxfovr != LGXF_ASK) {
-           i = ((ctx->cfg.logxfovr == LGXF_OVR) ? 2 : 1);
-       } else
-           i = askappend(ctx->frontend, ctx->currlogfilename);
-       if (i == 1)
-           writemod[0] = 'a';         /* set append mode */
-       else if (i == 0) {             /* cancelled */
-           ctx->lgfp = NULL;
-           ctx->cfg.logtype = 0;              /* disable logging */
-           return;
+       /* Flush row if necessary */
+       if (((p % 16) == 0) || (p == len) || omitted) {
+           if (output_pos) {
+               strcpy(dumpdata + 10+1+3*16+2+output_pos, "\r\n");
+               logwrite(ctx, dumpdata, strlen(dumpdata));
+               output_pos = 0;
+           }
        }
-    }
 
-    ctx->lgfp = f_open(ctx->currlogfilename, writemod);
-    if (ctx->lgfp) {                          /* enter into event log */
-       /* --- write header line into log file */
-       fputs("=~=~=~=~=~=~=~=~=~=~=~= PuTTY log ", ctx->lgfp);
-       strftime(buf, 24, "%Y.%m.%d %H:%M:%S", &tm);
-       fputs(buf, ctx->lgfp);
-       fputs(" =~=~=~=~=~=~=~=~=~=~=~=\r\n", ctx->lgfp);
-
-       sprintf(buf, "%s session log (%s mode) to file: ",
-               (writemod[0] == 'a') ? "Appending" : "Writing new",
-               (ctx->cfg.logtype == LGTYP_ASCII ? "ASCII" :
-                ctx->cfg.logtype == LGTYP_DEBUG ? "raw" :
-                ctx->cfg.logtype == LGTYP_PACKETS ? "SSH packets" : "<ukwn>"));
-       /* Make sure we do not exceed the output buffer size */
-       strncat(buf, filename_to_str(&ctx->currlogfilename), 128);
-       buf[strlen(buf)] = '\0';
-       logevent(ctx->frontend, buf);
     }
-}
 
-void logfclose(void *handle)
-{
-    struct LogContext *ctx = (struct LogContext *)handle;
-    if (ctx->lgfp) {
-       fclose(ctx->lgfp);
-       ctx->lgfp = NULL;
-    }
+    /* Tidy up */
+    if (omitted)
+       logprintf(ctx, "  (%d byte%s omitted)\r\n",
+                 omitted, (omitted==1?"":"s"));
+    logflush(ctx);
 }
 
 void *log_init(void *frontend, Config *cfg)
 {
     struct LogContext *ctx = snew(struct LogContext);
     ctx->lgfp = NULL;
+    ctx->state = CLOSED;
     ctx->frontend = frontend;
     ctx->cfg = *cfg;                  /* STRUCTURE COPY */
+    bufchain_init(&ctx->queue);
     return ctx;
 }
 
@@ -245,6 +312,7 @@ void log_free(void *handle)
     struct LogContext *ctx = (struct LogContext *)handle;
 
     logfclose(ctx);
+    bufchain_clear(&ctx->queue);
     sfree(ctx);
 }
 

diff --git a/mac/macterm.c b/mac/macterm.c
index 6374a1f..78efa65 100644 (file)
--- a/mac/macterm.c
+++ b/mac/macterm.c
@@ -1865,7 +1865,8 @@ void frontend_keypress(void *handle)
  * Ask whether to wipe a session log file before writing to it.
  * Returns 2 for wipe, 1 for append, 0 for cancel (don't log).
  */
-int askappend(void *frontend, Filename filename)
+int askappend(void *frontend, Filename filename,
+             void (*callback)(void *ctx, int result), void *ctx)
 {
 
     /* FIXME: not implemented yet. */

diff --git a/macosx/osxclass.h b/macosx/osxclass.h
index 76a8fc7..2e4d1de 100644 (file)
--- a/macosx/osxclass.h
+++ b/macosx/osxclass.h
@@ -27,6 +27,13 @@ extern AppController *controller;
  * The SessionWindow class, defined in osxwin.m.
  */
 
+struct alert_queue {
+    struct alert_queue *next;
+    NSAlert *alert;
+    void (*callback)(void *, int);
+    void *ctx;
+};
+
 @class SessionWindow;
 @class TerminalView;
 
@@ -40,8 +47,14 @@ extern AppController *controller;
     void *ldisc;
     Backend *back;
     void *backhandle;
+    /*
+     * The following two members relate to the currently active
+     * alert sheet, if any. They are NULL if there isn't one.
+     */
     void (*alert_callback)(void *, int);
     void *alert_ctx;
+    /* This queues future alerts that need to be shown. */
+    struct alert_queue *alert_qhead, *alert_qtail;
 }
 - (id)initWithConfig:(Config)cfg;
 - (void)drawStartFinish:(BOOL)start;

diff --git a/macosx/osxdlg.m b/macosx/osxdlg.m
index 588a814..f2d0902 100644 (file)
--- a/macosx/osxdlg.m
+++ b/macosx/osxdlg.m
@@ -306,9 +306,48 @@
  * Various special-purpose dialog boxes.
  */
 
-int askappend(void *frontend, Filename filename)
+struct appendstate {
+    void (*callback)(void *ctx, int result);
+    void *ctx;
+};
+
+static void askappend_callback(void *ctx, int result)
 {
-    return 0;                         /* FIXME */
+    struct appendstate *state = (struct appendstate *)ctx;
+
+    state->callback(state->ctx, (result == NSAlertFirstButtonReturn ? 2 :
+                                result == NSAlertSecondButtonReturn ? 1 : 0));
+    sfree(state);
+}
+
+int askappend(void *frontend, Filename filename,
+             void (*callback)(void *ctx, int result), void *ctx)
+{
+    static const char msgtemplate[] =
+       "The session log file \"%s\" already exists. "
+       "You can overwrite it with a new session log, "
+       "append your session log to the end of it, "
+       "or disable session logging for this session.";
+
+    char *text;
+    SessionWindow *win = (SessionWindow *)frontend;
+    struct appendstate *state;
+    NSAlert *alert;
+
+    text = dupprintf(msgtemplate, filename.path);
+
+    state = snew(struct appendstate);
+    state->callback = callback;
+    state->ctx = ctx;
+
+    alert = [[NSAlert alloc] init];
+    [alert setInformativeText:[NSString stringWithCString:text]];
+    [alert addButtonWithTitle:@"Overwrite"];
+    [alert addButtonWithTitle:@"Append"];
+    [alert addButtonWithTitle:@"Disable"];
+    [win startAlert:alert withCallback:askappend_callback andCtx:state];
+
+    return -1;
 }
 
 struct algstate {

diff --git a/macosx/osxwin.m b/macosx/osxwin.m
index 0424b0b..0b0c3ff 100644 (file)
--- a/macosx/osxwin.m
+++ b/macosx/osxwin.m
@@ -254,6 +254,7 @@
        if (realhost)
            sfree(realhost);           /* FIXME: do something with this */
     }
+    back->provide_logctx(backhandle, logctx);
 
     /*
      * Create a line discipline. (This must be done after creating
@@ -784,11 +785,27 @@ printf("n=%d c=U+%04x cm=U+%04x m=%08x\n", n, c, cm, m);
 - (void)startAlert:(NSAlert *)alert
     withCallback:(void (*)(void *, int))callback andCtx:(void *)ctx
 {
-    alert_callback = callback;
-    alert_ctx = ctx;                /* NB this is assumed to need freeing! */
-    [alert beginSheetModalForWindow:self modalDelegate:self
-     didEndSelector:@selector(alertSheetDidEnd:returnCode:contextInfo:)
-     contextInfo:NULL];
+    if (alert_ctx || alert_qhead) {
+       /*
+        * Queue this alert to be shown later.
+        */
+       struct alert_queue *qitem = snew(struct alert_queue);
+       qitem->next = NULL;
+       qitem->alert = alert;
+       qitem->callback = callback;
+       qitem->ctx = ctx;
+       if (alert_qtail)
+           alert_qtail->next = qitem;
+       else
+           alert_qhead = qitem;
+       alert_qtail = qitem;
+    } else {
+       alert_callback = callback;
+       alert_ctx = ctx;               /* NB this is assumed to need freeing! */
+       [alert beginSheetModalForWindow:self modalDelegate:self
+        didEndSelector:@selector(alertSheetDidEnd:returnCode:contextInfo:)
+        contextInfo:NULL];
+    }
 }
 
 - (void)alertSheetDidEnd:(NSAlert *)alert returnCode:(int)returnCode
@@ -803,19 +820,30 @@ printf("n=%d c=U+%04x cm=U+%04x m=%08x\n", n, c, cm, m);
 - (void)alertSheetDidFinishEnding:(id)object
 {
     int returnCode = [object intValue];
-    void (*this_callback)(void *, int);
-    void *this_ctx;
+
+    alert_callback(alert_ctx, returnCode);   /* transfers ownership of ctx */
 
     /*
-     * We must save the values of our alert_callback and alert_ctx
-     * fields, in case they are set up again by the callback
-     * function!
+     * If there's an alert in our queue (either already or because
+     * the callback just queued it), start it.
      */
-    this_callback = alert_callback;
-    this_ctx = alert_ctx;
-    alert_ctx = NULL;
-
-    this_callback(this_ctx, returnCode);   /* transfers ownership of ctx */
+    if (alert_qhead) {
+       struct alert_queue *qnext;
+
+       alert_callback = alert_qhead->callback;
+       alert_ctx = alert_qhead->ctx;
+       [alert_qhead->alert beginSheetModalForWindow:self modalDelegate:self
+        didEndSelector:@selector(alertSheetDidEnd:returnCode:contextInfo:)
+        contextInfo:NULL];
+
+       qnext = alert_qhead->next;
+       sfree(alert_qhead);
+       alert_qhead = qnext;
+       if (!qnext)
+           alert_qtail = NULL;
+    } else {
+       alert_ctx = NULL;
+    }
 }
 
 @end

diff --git a/putty.h b/putty.h
index 46708f1..4acfec1 100644 (file)
--- a/putty.h
+++ b/putty.h
@@ -916,7 +916,16 @@ int verify_ssh_host_key(void *frontend, char *host, int port, char *keytype,
  */
 int askalg(void *frontend, const char *algtype, const char *algname,
           void (*callback)(void *ctx, int result), void *ctx);
-int askappend(void *frontend, Filename filename);
+/*
+ * askappend can return four values:
+ * 
+ *  - 2 means overwrite the log file
+ *  - 1 means append to the log file
+ *  - 0 means cancel logging for this session
+ *  - -1 means please wait.
+ */
+int askappend(void *frontend, Filename filename,
+             void (*callback)(void *ctx, int result), void *ctx);
 
 /*
  * Exports from console.c (that aren't equivalents to things in

diff --git a/unix/gtkdlg.c b/unix/gtkdlg.c
index 2ef1831..8ab8598 100644 (file)
--- a/unix/gtkdlg.c
+++ b/unix/gtkdlg.c
@@ -2753,7 +2753,8 @@ void logevent_dlg(void *estuff, const char *string)
     es->nevents++;
 }
 
-int askappend(void *frontend, Filename filename)
+int askappend(void *frontend, Filename filename,
+             void (*callback)(void *ctx, int result), void *ctx)
 {
     static const char msgtemplate[] =
        "The session log file \"%.*s\" already exists. "

diff --git a/unix/uxcons.c b/unix/uxcons.c
index ef2866c..6579155 100644 (file)
--- a/unix/uxcons.c
+++ b/unix/uxcons.c
@@ -198,7 +198,8 @@ int askalg(void *frontend, const char *algtype, const char *algname,
  * Ask whether to wipe a session log file before writing to it.
  * Returns 2 for wipe, 1 for append, 0 for cancel (don't log).
  */
-int askappend(void *frontend, Filename filename)
+int askappend(void *frontend, Filename filename,
+             void (*callback)(void *ctx, int result), void *ctx)
 {
     static const char msgtemplate[] =
        "The session log file \"%.*s\" already exists.\n"

diff --git a/windows/wincons.c b/windows/wincons.c
index 0791358..d3ff56d 100644 (file)
--- a/windows/wincons.c
+++ b/windows/wincons.c
@@ -201,7 +201,8 @@ int askalg(void *frontend, const char *algtype, const char *algname,
  * Ask whether to wipe a session log file before writing to it.
  * Returns 2 for wipe, 1 for append, 0 for cancel (don't log).
  */
-int askappend(void *frontend, Filename filename)
+int askappend(void *frontend, Filename filename,
+             void (*callback)(void *ctx, int result), void *ctx)
 {
     HANDLE hin;
     DWORD savemode, i;

diff --git a/windows/windlg.c b/windows/windlg.c
index 742a761..c88e72d 100644 (file)
--- a/windows/windlg.c
+++ b/windows/windlg.c
@@ -851,7 +851,8 @@ int askalg(void *frontend, const char *algtype, const char *algname,
  * Ask whether to wipe a session log file before writing to it.
  * Returns 2 for wipe, 1 for append, 0 for cancel (don't log).
  */
-int askappend(void *frontend, Filename filename)
+int askappend(void *frontend, Filename filename,
+             void (*callback)(void *ctx, int result), void *ctx)
 {
     static const char msgtemplate[] =
        "The session log file \"%.*s\" already exists.\n"