--- /dev/null
+/*\r
+ * Session logging.\r
+ */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <ctype.h>\r
+\r
+#include <time.h>\r
+#include <assert.h>\r
+\r
+#include "putty.h"\r
+\r
+/* log session to file stuff ... */\r
+struct LogContext {\r
+ FILE *lgfp;\r
+ enum { L_CLOSED, L_OPENING, L_OPEN, L_ERROR } state;\r
+ bufchain queue;\r
+ Filename currlogfilename;\r
+ void *frontend;\r
+ Config cfg;\r
+};\r
+\r
+static void xlatlognam(Filename *d, Filename s, char *hostname, struct tm *tm);\r
+\r
+/*\r
+ * Internal wrapper function which must be called for _all_ output\r
+ * to the log file. It takes care of opening the log file if it\r
+ * isn't open, buffering data if it's in the process of being\r
+ * opened asynchronously, etc.\r
+ */\r
+static void logwrite(struct LogContext *ctx, void *data, int len)\r
+{\r
+ /*\r
+ * In state L_CLOSED, we call logfopen, which will set the state\r
+ * to one of L_OPENING, L_OPEN or L_ERROR. Hence we process all of\r
+ * those three _after_ processing L_CLOSED.\r
+ */\r
+ if (ctx->state == L_CLOSED)\r
+ logfopen(ctx);\r
+\r
+ if (ctx->state == L_OPENING) {\r
+ bufchain_add(&ctx->queue, data, len);\r
+ } else if (ctx->state == L_OPEN) {\r
+ assert(ctx->lgfp);\r
+ if (fwrite(data, 1, len, ctx->lgfp) < (size_t)len) {\r
+ logfclose(ctx);\r
+ ctx->state = L_ERROR;\r
+ /* Log state is L_ERROR so this won't cause a loop */\r
+ logevent(ctx->frontend,\r
+ "Disabled writing session log due to error while writing");\r
+ }\r
+ } /* else L_ERROR, so ignore the write */\r
+}\r
+\r
+/*\r
+ * Convenience wrapper on logwrite() which printf-formats the\r
+ * string.\r
+ */\r
+static void logprintf(struct LogContext *ctx, const char *fmt, ...)\r
+{\r
+ va_list ap;\r
+ char *data;\r
+\r
+ va_start(ap, fmt);\r
+ data = dupvprintf(fmt, ap);\r
+ va_end(ap);\r
+\r
+ logwrite(ctx, data, strlen(data));\r
+ sfree(data);\r
+}\r
+\r
+/*\r
+ * Flush any open log file.\r
+ */\r
+void logflush(void *handle) {\r
+ struct LogContext *ctx = (struct LogContext *)handle;\r
+ if (ctx->cfg.logtype > 0)\r
+ if (ctx->state == L_OPEN)\r
+ fflush(ctx->lgfp);\r
+}\r
+\r
+static void logfopen_callback(void *handle, int mode)\r
+{\r
+ struct LogContext *ctx = (struct LogContext *)handle;\r
+ char buf[256], *event;\r
+ struct tm tm;\r
+ const char *fmode;\r
+\r
+ if (mode == 0) {\r
+ ctx->state = L_ERROR; /* disable logging */\r
+ } else {\r
+ fmode = (mode == 1 ? "ab" : "wb");\r
+ ctx->lgfp = f_open(ctx->currlogfilename, fmode, FALSE);\r
+ if (ctx->lgfp)\r
+ ctx->state = L_OPEN;\r
+ else\r
+ ctx->state = L_ERROR;\r
+ }\r
+\r
+ if (ctx->state == L_OPEN) {\r
+ /* Write header line into log file. */\r
+ tm = ltime();\r
+ strftime(buf, 24, "%Y.%m.%d %H:%M:%S", &tm);\r
+ logprintf(ctx, "=~=~=~=~=~=~=~=~=~=~=~= PuTTY log %s"\r
+ " =~=~=~=~=~=~=~=~=~=~=~=\r\n", buf);\r
+ }\r
+\r
+ event = dupprintf("%s session log (%s mode) to file: %s",\r
+ ctx->state == L_ERROR ?\r
+ (mode == 0 ? "Disabled writing" : "Error writing") :\r
+ (mode == 1 ? "Appending" : "Writing new"),\r
+ (ctx->cfg.logtype == LGTYP_ASCII ? "ASCII" :\r
+ ctx->cfg.logtype == LGTYP_DEBUG ? "raw" :\r
+ ctx->cfg.logtype == LGTYP_PACKETS ? "SSH packets" :\r
+ ctx->cfg.logtype == LGTYP_SSHRAW ? "SSH raw data" :\r
+ "unknown"),\r
+ filename_to_str(&ctx->currlogfilename));\r
+ logevent(ctx->frontend, event);\r
+ sfree(event);\r
+\r
+ /*\r
+ * Having either succeeded or failed in opening the log file,\r
+ * we should write any queued data out.\r
+ */\r
+ assert(ctx->state != L_OPENING); /* make _sure_ it won't be requeued */\r
+ while (bufchain_size(&ctx->queue)) {\r
+ void *data;\r
+ int len;\r
+ bufchain_prefix(&ctx->queue, &data, &len);\r
+ logwrite(ctx, data, len);\r
+ bufchain_consume(&ctx->queue, len);\r
+ }\r
+}\r
+\r
+/*\r
+ * Open the log file. Takes care of detecting an already-existing\r
+ * file and asking the user whether they want to append, overwrite\r
+ * or cancel logging.\r
+ */\r
+void logfopen(void *handle)\r
+{\r
+ struct LogContext *ctx = (struct LogContext *)handle;\r
+ struct tm tm;\r
+ int mode;\r
+\r
+ /* Prevent repeat calls */\r
+ if (ctx->state != L_CLOSED)\r
+ return;\r
+\r
+ if (!ctx->cfg.logtype)\r
+ return;\r
+\r
+ tm = ltime();\r
+\r
+ /* substitute special codes in file name */\r
+ xlatlognam(&ctx->currlogfilename, ctx->cfg.logfilename,ctx->cfg.host, &tm);\r
+\r
+ ctx->lgfp = f_open(ctx->currlogfilename, "r", FALSE); /* file already present? */\r
+ if (ctx->lgfp) {\r
+ fclose(ctx->lgfp);\r
+ if (ctx->cfg.logxfovr != LGXF_ASK) {\r
+ mode = ((ctx->cfg.logxfovr == LGXF_OVR) ? 2 : 1);\r
+ } else\r
+ mode = askappend(ctx->frontend, ctx->currlogfilename,\r
+ logfopen_callback, ctx);\r
+ } else\r
+ mode = 2; /* create == overwrite */\r
+\r
+ if (mode < 0)\r
+ ctx->state = L_OPENING;\r
+ else\r
+ logfopen_callback(ctx, mode); /* open the file */\r
+}\r
+\r
+void logfclose(void *handle)\r
+{\r
+ struct LogContext *ctx = (struct LogContext *)handle;\r
+ if (ctx->lgfp) {\r
+ fclose(ctx->lgfp);\r
+ ctx->lgfp = NULL;\r
+ }\r
+ ctx->state = L_CLOSED;\r
+}\r
+\r
+/*\r
+ * Log session traffic.\r
+ */\r
+void logtraffic(void *handle, unsigned char c, int logmode)\r
+{\r
+ struct LogContext *ctx = (struct LogContext *)handle;\r
+ if (ctx->cfg.logtype > 0) {\r
+ if (ctx->cfg.logtype == logmode)\r
+ logwrite(ctx, &c, 1);\r
+ }\r
+}\r
+\r
+/*\r
+ * Log an Event Log entry. Used in SSH packet logging mode; this is\r
+ * also as convenient a place as any to put the output of Event Log\r
+ * entries to stderr when a command-line tool is in verbose mode.\r
+ * (In particular, this is a better place to put it than in the\r
+ * front ends, because it only has to be done once for all\r
+ * platforms. Platforms which don't have a meaningful stderr can\r
+ * just avoid defining FLAG_STDERR.\r
+ */\r
+void log_eventlog(void *handle, const char *event)\r
+{\r
+ struct LogContext *ctx = (struct LogContext *)handle;\r
+ if ((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)) {\r
+ fprintf(stderr, "%s\n", event);\r
+ fflush(stderr);\r
+ }\r
+ /* If we don't have a context yet (eg winnet.c init) then skip entirely */\r
+ if (!ctx)\r
+ return;\r
+ if (ctx->cfg.logtype != LGTYP_PACKETS &&\r
+ ctx->cfg.logtype != LGTYP_SSHRAW)\r
+ return;\r
+ logprintf(ctx, "Event Log: %s\r\n", event);\r
+ logflush(ctx);\r
+}\r
+\r
+/*\r
+ * Log an SSH packet.\r
+ * If n_blanks != 0, blank or omit some parts.\r
+ * Set of blanking areas must be in increasing order.\r
+ */\r
+void log_packet(void *handle, int direction, int type,\r
+ char *texttype, const void *data, int len,\r
+ int n_blanks, const struct logblank_t *blanks,\r
+ const unsigned long *seq)\r
+{\r
+ struct LogContext *ctx = (struct LogContext *)handle;\r
+ char dumpdata[80], smalldata[5];\r
+ int p = 0, b = 0, omitted = 0;\r
+ int output_pos = 0; /* NZ if pending output in dumpdata */\r
+\r
+ if (!(ctx->cfg.logtype == LGTYP_SSHRAW ||\r
+ (ctx->cfg.logtype == LGTYP_PACKETS && texttype)))\r
+ return;\r
+\r
+ /* Packet header. */\r
+ if (texttype) {\r
+ if (seq) {\r
+ logprintf(ctx, "%s packet #0x%lx, type %d / 0x%02x (%s)\r\n",\r
+ direction == PKT_INCOMING ? "Incoming" : "Outgoing",\r
+ *seq, type, type, texttype);\r
+ } else {\r
+ logprintf(ctx, "%s packet type %d / 0x%02x (%s)\r\n",\r
+ direction == PKT_INCOMING ? "Incoming" : "Outgoing",\r
+ type, type, texttype);\r
+ }\r
+ } else {\r
+ logprintf(ctx, "%s raw data\r\n",\r
+ direction == PKT_INCOMING ? "Incoming" : "Outgoing");\r
+ }\r
+\r
+ /*\r
+ * Output a hex/ASCII dump of the packet body, blanking/omitting\r
+ * parts as specified.\r
+ */\r
+ while (p < len) {\r
+ int blktype;\r
+\r
+ /* Move to a current entry in the blanking array. */\r
+ while ((b < n_blanks) &&\r
+ (p >= blanks[b].offset + blanks[b].len))\r
+ b++;\r
+ /* Work out what type of blanking to apply to\r
+ * this byte. */\r
+ blktype = PKTLOG_EMIT; /* default */\r
+ if ((b < n_blanks) &&\r
+ (p >= blanks[b].offset) &&\r
+ (p < blanks[b].offset + blanks[b].len))\r
+ blktype = blanks[b].type;\r
+\r
+ /* If we're about to stop omitting, it's time to say how\r
+ * much we omitted. */\r
+ if ((blktype != PKTLOG_OMIT) && omitted) {\r
+ logprintf(ctx, " (%d byte%s omitted)\r\n",\r
+ omitted, (omitted==1?"":"s"));\r
+ omitted = 0;\r
+ }\r
+\r
+ /* (Re-)initialise dumpdata as necessary\r
+ * (start of row, or if we've just stopped omitting) */\r
+ if (!output_pos && !omitted)\r
+ sprintf(dumpdata, " %08x%*s\r\n", p-(p%16), 1+3*16+2+16, "");\r
+\r
+ /* Deal with the current byte. */\r
+ if (blktype == PKTLOG_OMIT) {\r
+ omitted++;\r
+ } else {\r
+ int c;\r
+ if (blktype == PKTLOG_BLANK) {\r
+ c = 'X';\r
+ sprintf(smalldata, "XX");\r
+ } else { /* PKTLOG_EMIT */\r
+ c = ((unsigned char *)data)[p];\r
+ sprintf(smalldata, "%02x", c);\r
+ }\r
+ dumpdata[10+2+3*(p%16)] = smalldata[0];\r
+ dumpdata[10+2+3*(p%16)+1] = smalldata[1];\r
+ dumpdata[10+1+3*16+2+(p%16)] = (isprint(c) ? c : '.');\r
+ output_pos = (p%16) + 1;\r
+ }\r
+\r
+ p++;\r
+\r
+ /* Flush row if necessary */\r
+ if (((p % 16) == 0) || (p == len) || omitted) {\r
+ if (output_pos) {\r
+ strcpy(dumpdata + 10+1+3*16+2+output_pos, "\r\n");\r
+ logwrite(ctx, dumpdata, strlen(dumpdata));\r
+ output_pos = 0;\r
+ }\r
+ }\r
+\r
+ }\r
+\r
+ /* Tidy up */\r
+ if (omitted)\r
+ logprintf(ctx, " (%d byte%s omitted)\r\n",\r
+ omitted, (omitted==1?"":"s"));\r
+ logflush(ctx);\r
+}\r
+\r
+void *log_init(void *frontend, Config *cfg)\r
+{\r
+ struct LogContext *ctx = snew(struct LogContext);\r
+ ctx->lgfp = NULL;\r
+ ctx->state = L_CLOSED;\r
+ ctx->frontend = frontend;\r
+ ctx->cfg = *cfg; /* STRUCTURE COPY */\r
+ bufchain_init(&ctx->queue);\r
+ return ctx;\r
+}\r
+\r
+void log_free(void *handle)\r
+{\r
+ struct LogContext *ctx = (struct LogContext *)handle;\r
+\r
+ logfclose(ctx);\r
+ bufchain_clear(&ctx->queue);\r
+ sfree(ctx);\r
+}\r
+\r
+void log_reconfig(void *handle, Config *cfg)\r
+{\r
+ struct LogContext *ctx = (struct LogContext *)handle;\r
+ int reset_logging;\r
+\r
+ if (!filename_equal(ctx->cfg.logfilename, cfg->logfilename) ||\r
+ ctx->cfg.logtype != cfg->logtype)\r
+ reset_logging = TRUE;\r
+ else\r
+ reset_logging = FALSE;\r
+\r
+ if (reset_logging)\r
+ logfclose(ctx);\r
+\r
+ ctx->cfg = *cfg; /* STRUCTURE COPY */\r
+\r
+ if (reset_logging)\r
+ logfopen(ctx);\r
+}\r
+\r
+/*\r
+ * translate format codes into time/date strings\r
+ * and insert them into log file name\r
+ *\r
+ * "&Y":YYYY "&m":MM "&d":DD "&T":hhmmss "&h":<hostname> "&&":&\r
+ */\r
+static void xlatlognam(Filename *dest, Filename src,\r
+ char *hostname, struct tm *tm) {\r
+ char buf[10], *bufp;\r
+ int size;\r
+ char buffer[FILENAME_MAX];\r
+ int len = sizeof(buffer)-1;\r
+ char *d;\r
+ const char *s;\r
+\r
+ d = buffer;\r
+ s = filename_to_str(&src);\r
+\r
+ while (*s) {\r
+ /* Let (bufp, len) be the string to append. */\r
+ bufp = buf; /* don't usually override this */\r
+ if (*s == '&') {\r
+ char c;\r
+ s++;\r
+ size = 0;\r
+ if (*s) switch (c = *s++, tolower((unsigned char)c)) {\r
+ case 'y':\r
+ size = strftime(buf, sizeof(buf), "%Y", tm);\r
+ break;\r
+ case 'm':\r
+ size = strftime(buf, sizeof(buf), "%m", tm);\r
+ break;\r
+ case 'd':\r
+ size = strftime(buf, sizeof(buf), "%d", tm);\r
+ break;\r
+ case 't':\r
+ size = strftime(buf, sizeof(buf), "%H%M%S", tm);\r
+ break;\r
+ case 'h':\r
+ bufp = hostname;\r
+ size = strlen(bufp);\r
+ break;\r
+ default:\r
+ buf[0] = '&';\r
+ size = 1;\r
+ if (c != '&')\r
+ buf[size++] = c;\r
+ }\r
+ } else {\r
+ buf[0] = *s++;\r
+ size = 1;\r
+ }\r
+ if (size > len)\r
+ size = len;\r
+ memcpy(d, bufp, size);\r
+ d += size;\r
+ len -= size;\r
+ }\r
+ *d = '\0';\r
+\r
+ *dest = filename_from_str(buffer);\r
+}\r
OSDN Git Service
