1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
#include "logging.h"
// Write the line 'str' to the relevant log file such as
// '#channel.log' or 'nickname.log'. 'ournick' is our own
// nick and is used to determine which log file to write to
// if the type is LOG_PRIVMSG.
// 'basedir' is the directory in which the 'logs' directory
// will be created in which logs are to be written.
//
// If LOG_PRIVMSG then it expects a string in the format:
// :from!bar@baz PRIVMSG to :hello world
//
// If LOG_JOINPART then
// Expects a string in the format:
// :nick!bar@baz JOIN :#blabouncer
// or
// :nick!bar@baz PART #blabouncer
//
// With the ":foo!bar@baz "prefix being important for either
// type.
//
// Returns 1 on success or 0 on failure.
int logline(char *str, char *ournick, char *basedir, int type) {
// Filename to write to, gets built as we go
char filename[MAXCHAR];
// Log line to ultimately write, gets built as we go
char line[MAXCHAR];
// Variables for LOG_JOINPART (can't define directly inside switch case)
int pos;
// Build array of each space-separated token
char tokens[MAXTOKENS][MAXDATASIZE];
char *token;
// Split out the first three space-separated parts of the string, leaving the rest.
// If LOG_PRIVMSG:
// This gets us the prefix (containing the "from" nick), the PRIVMSG command (not needed),
// and the "to" nick or channel. Plus the rest of the string intact (which is the actual
// message).
// If LOG_JOINPART:
// This gets us the prefix (containing the joined/parted nick), the JOIN/PART command (not needed),
// and the channel name.
for (int i = 0; i < 3; i++) {
// Try to split
if ((token = strsep(&str, " ")) == NULL) {
printf("Error splitting string for logging, exiting!\n");
exit(1);
}
// Copy into the token array (strlen + 1 to get the NULL terminator)
strncpy(tokens[i], token, strlen(token) + 1);
printf("logline(): extracted '%s'.\n", tokens[i]);
}
switch(type) {
case LOG_PRIVMSG:
// Extract the username from the prefix
extractnickfromprefix(tokens[0]);
// Remove the leading ":" from the real message
stripprefix(str);
// Build the log filename
// If the message was sent to us, then log it in the sender's log file
if (strncmp(tokens[2], ournick, strlen(tokens[0])) == 0) {
snprintf(filename, MAXCHAR, "%s/logs/%s.log", basedir, tokens[0]);
} else {
// Otherwise log it in the "to" log file
snprintf(filename, MAXCHAR, "%s/logs/%s.log", basedir, tokens[2]);
}
printf("logline(): Logging PRIVMSG from '%s' to '%s' message '%s' in filename '%s'.\n", tokens[0], tokens[2], str, filename);
break;
case LOG_JOINPART:
// Find the start of the channel name
// If it's a JOIN
if (tokens[2][0] == ':') {
pos = 1;
} else if (tokens[2][0] == '#') {
// Perhaps it's a PART
pos = 0;
} else {
// If not found, return 0
return 0;
}
snprintf(filename, MAXCHAR, "%s/logs/%s.log", basedir, tokens[2] + pos);
printf("logline(): Logging JOIN/PART to/from '%s' in filename '%s'.\n", tokens[2] + pos, filename);
// Build a friendly message (e.g. ":nick!user@host JOIN #channel" -> "nick (user@host) has joined #channel")
// Find the bang in the prefix
char *ret;
int posbang;
if ((ret = strstr(tokens[0], "!")) != NULL) {
// Position within str of "!"
posbang = ret - tokens[0];
} else {
// No idea what happened, let's abandon ship
return 0;
}
// Make it a null character
tokens[0][posbang] = '\0';
// Swap JOINed or PARTed for a friendly word
if (strncmp(tokens[1], "JOIN", strlen("JOIN")) == 0) {
snprintf(tokens[1], strlen("joined") + 1, "joined");
} else if (strncmp(tokens[1], "PART", strlen("PART")) == 0) {
snprintf(tokens[1], strlen("left") + 1, "left");
}
// Copy the nick, then user@host, then whether it was a join or part, then the channel name the string to send
snprintf(line, MAXCHAR, "%s (%s) has %s %s", tokens[0] + 1, tokens[0] + posbang + 1, tokens[1], tokens[2] + pos);
break;
default :
printf("Unknown log type '%d', returning 0.\n", type);
return 0;
}
// Make sure the log directory exists
char logdir[PATH_MAX];
snprintf(logdir, PATH_MAX, "%s/logs/", basedir);
struct stat st = {0};
if (stat(logdir, &st) == -1) {
if (mkdir(logdir, 0700)) {
printf("Error creating log directory '%s'.\n", logdir);
exit(1);
} else {
printf("logline(): log directory '%s'.\n", logdir);
}
}
FILE *fp;
int bytes = 0;
fp = fopen(filename, "a");
if (fp == NULL) {
printf("error: could not open log file '%s' for writing.\n", filename);
exit(1);
}
// Get a current time string to prepend - TODO - Make this customisable.
time_t rawtime;
struct tm * timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
// Strip the trailing newline
char timestr[MAXCHAR];
snprintf(timestr, MAXCHAR, "%s", asctime(timeinfo));
timestr[strlen(timestr) - 1] = '\0';
if (type == LOG_PRIVMSG) {
// Prepend the time string and "from" nick
if (!snprintf(line, MAXCHAR, "%s <%s> %s", timestr, tokens[0], str)) {
fprintf(stderr, "Error while preparing log string to write!\n");
exit(1);
}
} else if (type == LOG_JOINPART) {
// Prepend the time string
char line2[MAXCHAR];
if (!snprintf(line2, MAXCHAR, "%s %s", timestr, line)) {
fprintf(stderr, "Error while preparing log string to write!\n");
exit(1);
}
// Copy back to line to write
snprintf(line, MAXCHAR, "%s", line2);
}
// Ensure the line finishes with CRLF
appendcrlf(line);
printf("logline(): Complete log string to write: '%s', length '%ld'.\n", line, strlen(line));
// Write complete line to file
if ((bytes = fprintf(fp, line)) < 0) {
printf("error: could not write to log file.\n");
exit(1);
}
fclose(fp);
return bytes;
}
|
