Merge remote-tracking branch 'origin/released'

Conflicts:
	tools/plink/sshbn.c

1 files changed, 60 insertions, 40 deletions

diff --git a/tools/plink/logging.c b/tools/plink/logging.c
index 4c7aa918c..a7f76c35a 100644
--- a/tools/plink/logging.c
+++ b/tools/plink/logging.c
@@ -16,12 +16,13 @@ struct LogContext {
     FILE *lgfp;

     enum { L_CLOSED, L_OPENING, L_OPEN, L_ERROR } state;

     bufchain queue;

-    Filename currlogfilename;

+    Filename *currlogfilename;

     void *frontend;

-    Config cfg;

+    Conf *conf;

+    int logtype;		       /* cached out of conf */

 };

 

-static void xlatlognam(Filename *d, Filename s, char *hostname, struct tm *tm);

+static Filename *xlatlognam(Filename *s, char *hostname, struct tm *tm);

 

 /*

  * Internal wrapper function which must be called for _all_ output

@@ -43,7 +44,7 @@ static void logwrite(struct LogContext *ctx, void *data, int len)
 	bufchain_add(&ctx->queue, data, len);

     } else if (ctx->state == L_OPEN) {

 	assert(ctx->lgfp);

-	if (fwrite(data, 1, len, ctx->lgfp) < len) {

+	if (fwrite(data, 1, len, ctx->lgfp) < (size_t)len) {

 	    logfclose(ctx);

 	    ctx->state = L_ERROR;

 	    /* Log state is L_ERROR so this won't cause a loop */

@@ -75,7 +76,7 @@ static void logprintf(struct LogContext *ctx, const char *fmt, ...)
  */

 void logflush(void *handle) {

     struct LogContext *ctx = (struct LogContext *)handle;

-    if (ctx->cfg.logtype > 0)

+    if (ctx->logtype > 0)

 	if (ctx->state == L_OPEN)

 	    fflush(ctx->lgfp);

 }

@@ -110,12 +111,12 @@ static void logfopen_callback(void *handle, int mode)
 		      ctx->state == L_ERROR ?

 		      (mode == 0 ? "Disabled writing" : "Error 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" :

-		       ctx->cfg.logtype == LGTYP_SSHRAW ? "SSH raw data" :

+		      (ctx->logtype == LGTYP_ASCII ? "ASCII" :

+		       ctx->logtype == LGTYP_DEBUG ? "raw" :

+		       ctx->logtype == LGTYP_PACKETS ? "SSH packets" :

+		       ctx->logtype == LGTYP_SSHRAW ? "SSH raw data" :

 		       "unknown"),

-		      filename_to_str(&ctx->currlogfilename));

+		      filename_to_str(ctx->currlogfilename));

     logevent(ctx->frontend, event);

     sfree(event);

 

@@ -148,19 +149,24 @@ void logfopen(void *handle)
     if (ctx->state != L_CLOSED)

 	return;

 

-    if (!ctx->cfg.logtype)

+    if (!ctx->logtype)

 	return;

 

     tm = ltime();

 

     /* substitute special codes in file name */

-    xlatlognam(&ctx->currlogfilename, ctx->cfg.logfilename,ctx->cfg.host, &tm);

+    if (ctx->currlogfilename)

+        filename_free(ctx->currlogfilename);

+    ctx->currlogfilename = 

+        xlatlognam(conf_get_filename(ctx->conf, CONF_logfilename),

+                   conf_get_str(ctx->conf, CONF_host), &tm);

 

     ctx->lgfp = f_open(ctx->currlogfilename, "r", FALSE);  /* file already present? */

     if (ctx->lgfp) {

+	int logxfovr = conf_get_int(ctx->conf, CONF_logxfovr);

 	fclose(ctx->lgfp);

-	if (ctx->cfg.logxfovr != LGXF_ASK) {

-	    mode = ((ctx->cfg.logxfovr == LGXF_OVR) ? 2 : 1);

+	if (logxfovr != LGXF_ASK) {

+	    mode = ((logxfovr == LGXF_OVR) ? 2 : 1);

 	} else

 	    mode = askappend(ctx->frontend, ctx->currlogfilename,

 			     logfopen_callback, ctx);

@@ -189,8 +195,8 @@ void logfclose(void *handle)
 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)

+    if (ctx->logtype > 0) {

+	if (ctx->logtype == logmode)

 	    logwrite(ctx, &c, 1);

     }

 }

@@ -214,8 +220,8 @@ void log_eventlog(void *handle, const char *event)
     /* If we don't have a context yet (eg winnet.c init) then skip entirely */

     if (!ctx)

 	return;

-    if (ctx->cfg.logtype != LGTYP_PACKETS &&

-	ctx->cfg.logtype != LGTYP_SSHRAW)

+    if (ctx->logtype != LGTYP_PACKETS &&

+	ctx->logtype != LGTYP_SSHRAW)

 	return;

     logprintf(ctx, "Event Log: %s\r\n", event);

     logflush(ctx);

@@ -236,8 +242,8 @@ void log_packet(void *handle, int direction, int type,
     int p = 0, b = 0, omitted = 0;

     int output_pos = 0; /* NZ if pending output in dumpdata */

 

-    if (!(ctx->cfg.logtype == LGTYP_SSHRAW ||

-          (ctx->cfg.logtype == LGTYP_PACKETS && texttype)))

+    if (!(ctx->logtype == LGTYP_SSHRAW ||

+          (ctx->logtype == LGTYP_PACKETS && texttype)))

 	return;

 

     /* Packet header. */

@@ -326,13 +332,15 @@ void log_packet(void *handle, int direction, int type,
     logflush(ctx);

 }

 

-void *log_init(void *frontend, Config *cfg)

+void *log_init(void *frontend, Conf *conf)

 {

     struct LogContext *ctx = snew(struct LogContext);

     ctx->lgfp = NULL;

     ctx->state = L_CLOSED;

     ctx->frontend = frontend;

-    ctx->cfg = *cfg;		       /* STRUCTURE COPY */

+    ctx->conf = conf_copy(conf);

+    ctx->logtype = conf_get_int(ctx->conf, CONF_logtype);

+    ctx->currlogfilename = NULL;

     bufchain_init(&ctx->queue);

     return ctx;

 }

@@ -343,16 +351,20 @@ void log_free(void *handle)
 

     logfclose(ctx);

     bufchain_clear(&ctx->queue);

+    if (ctx->currlogfilename)

+        filename_free(ctx->currlogfilename);

     sfree(ctx);

 }

 

-void log_reconfig(void *handle, Config *cfg)

+void log_reconfig(void *handle, Conf *conf)

 {

     struct LogContext *ctx = (struct LogContext *)handle;

     int reset_logging;

 

-    if (!filename_equal(ctx->cfg.logfilename, cfg->logfilename) ||

-	ctx->cfg.logtype != cfg->logtype)

+    if (!filename_equal(conf_get_filename(ctx->conf, CONF_logfilename),

+			conf_get_filename(conf, CONF_logfilename)) ||

+	conf_get_int(ctx->conf, CONF_logtype) !=

+	conf_get_int(conf, CONF_logtype))

 	reset_logging = TRUE;

     else

 	reset_logging = FALSE;

@@ -360,7 +372,10 @@ void log_reconfig(void *handle, Config *cfg)
     if (reset_logging)

 	logfclose(ctx);

 

-    ctx->cfg = *cfg;		       /* STRUCTURE COPY */

+    conf_free(ctx->conf);

+    ctx->conf = conf_copy(conf);

+

+    ctx->logtype = conf_get_int(ctx->conf, CONF_logtype);

 

     if (reset_logging)

 	logfopen(ctx);

@@ -372,17 +387,19 @@ void log_reconfig(void *handle, Config *cfg)
  *

  * "&Y":YYYY   "&m":MM   "&d":DD   "&T":hhmmss   "&h":<hostname>   "&&":&

  */

-static void xlatlognam(Filename *dest, Filename src,

-		       char *hostname, struct tm *tm) {

+static Filename *xlatlognam(Filename *src, char *hostname, struct tm *tm)

+{

     char buf[10], *bufp;

     int size;

-    char buffer[FILENAME_MAX];

-    int len = sizeof(buffer)-1;

-    char *d;

+    char *buffer;

+    int buflen, bufsize;

     const char *s;

+    Filename *ret;

 

-    d = buffer;

-    s = filename_to_str(&src);

+    bufsize = FILENAME_MAX;

+    buffer = snewn(bufsize, char);

+    buflen = 0;

+    s = filename_to_str(src);

 

     while (*s) {

 	/* Let (bufp, len) be the string to append. */

@@ -418,13 +435,16 @@ static void xlatlognam(Filename *dest, Filename src,
 	    buf[0] = *s++;

 	    size = 1;

 	}

-	if (size > len)

-	    size = len;

-	memcpy(d, bufp, size);

-	d += size;

-	len -= size;

+        if (bufsize <= buflen + size) {

+            bufsize = (buflen + size) * 5 / 4 + 512;

+            buffer = sresize(buffer, bufsize, char);

+        }

+	memcpy(buffer + buflen, bufp, size);

+	buflen += size;

     }

-    *d = '\0';

+    buffer[buflen] = '\0';

 

-    *dest = filename_from_str(buffer);

+    ret = filename_from_str(buffer);

+    sfree(buffer);

+    return ret;

 }