/[imapfilter]/imapfilter/response.c
ViewVC logotype

Diff of /imapfilter/response.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.9.2.2 by lefcha, Wed Oct 31 20:54:20 2001 UTC revision 1.53 by lefcha, Sun Feb 15 15:31:54 2004 UTC
# Line 1  Line 1 
1  #include <stdio.h>  #include <stdio.h>
 #include <unistd.h>  
2  #include <stdlib.h>  #include <stdlib.h>
 #include <ctype.h>  
 #include <errno.h>  
3  #include <string.h>  #include <string.h>
4  #include <fcntl.h>  #include <strings.h>
5  #include <sys/time.h>  #include <ctype.h>
6  #include <sys/types.h>  #include <sys/types.h>          /* For POSIX.1-2001 non-conformant systems. */
7  #include <regex.h>  #include <regex.h>
8    #include <setjmp.h>
9    
10  #include "config.h"  #include "config.h"
11  #include "imapfilter.h"  #include "imapfilter.h"
12    #include "buffer.h"
13    
14    
15    extern connection_t connpri, connaux;
16    extern options_t opts;
17    extern jmp_buf acctloop;
18    
19  extern int sock;  buffer_t ibuf;                  /* Input buffer. */
20  extern unsigned int options;  
21    
22    void receive_response(connection_t * conn, char *buf);
23    void response_bye(char *buf);
24    int analyze_response(connection_t * conn, char *buf);
25    
26    
27  /*  /*
28   * Read data the server sent.   * Read one packet of data that the server sent.
29   */   */
30  int receive_response(char *buf)  void
31    receive_response(connection_t * conn, char *buf)
32  {  {
     int flags;  
     fd_set fds;  
     struct timeval tv;  
33    
34      memset(buf, 0, RESPONSE_BUF);          if (socket_read(conn, buf) == ERROR_NETWORK)
35                    longjmp(acctloop, -1);
36    
37            debug("getting response (%s):\n\n%s\n",
38                (conn == &connpri ? "primary" : "auxiliary"), buf);
39    }
40    
     tv.tv_sec = 20;  
     tv.tv_usec = 0;  
41    
42      flags = fcntl(sock, F_GETFL, 0);  /*
43      fcntl(sock, F_SETFL, flags | O_NONBLOCK);   * Get server response to client's request.
44     */
45    int
46    response_generic(connection_t * conn, unsigned int tag)
47    {
48    
49      FD_ZERO(&fds);          buffer_reset(&ibuf);
     FD_SET(sock, &fds);  
50    
51      if ((select(sock + 1, &fds, NULL, NULL, &tv) > 0)          do {
52          && FD_ISSET(sock, &fds)) {                  buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
53          if (read(sock, buf, RESPONSE_BUF - 1) != -1) {                  receive_response(conn, ibuf.data + strlen(ibuf.data));
54  #ifdef DEBUG                  response_bye(ibuf.data);
55              printf("\n%s\n", buf);          } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
 #endif  
             fcntl(sock, F_SETFL, flags);  
56    
57              return analyze_response(buf);          return analyze_response(conn, ibuf.data);
58          }  }
     }  
     fcntl(sock, F_SETFL, flags);  
59    
     fatal(ERROR_NETWORK, "imapfilter: waiting input from socket; %s\n",  
           strerror(errno));  
60    
61      return ERROR_NETWORK;  /*
62     * Check if server sent a BYE response (connection is closed immediately).
63     */
64    void
65    response_bye(char *buf)
66    {
67    
68            if (strcasestr(buf, "* BYE"))
69                    longjmp(acctloop, -1);
70  }  }
71    
72    
73  /*  /*
74   * Get server response to client's request.   * Process the greeting that server sends during connection.
75   */   */
76  int server_response(unsigned int tag)  int
77    response_greeting(connection_t * conn)
78  {  {
     int r;  
     char buf[RESPONSE_BUF];  
79    
80      do          buffer_reset(&ibuf);
81          r = receive_response(buf);  
82      while (tag && !strcasestr(buf, ultostr(tag, 16)));          receive_response(conn, ibuf.data);
83    
84            verbose("%s: %s", (conn == &connpri ? "S" : "s"), ibuf);
85    
86            response_bye(ibuf.data);
87    
88      return r;          if (strcasestr(ibuf.data, "* PREAUTH"))
89                    return RESPONSE_PREAUTH;
90    
91            return RESPONSE_OK;
92  }  }
93    
94    
95  /*  /*
96   * Process the greeting that server sends during connection.   * Process the data that server sent due to IMAP LOGOUT client request.
97   */   */
98  int greeting_response(void)  int
99    response_logout(connection_t * conn, unsigned int tag)
100  {  {
     char buf[RESPONSE_BUF];  
101    
102      receive_response(buf);          buffer_reset(&ibuf);
103    
104      if (strcasestr(buf, "BYE"))          do {
105          return RESPONSE_BYE;                  buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
106                    receive_response(conn, ibuf.data + strlen(ibuf.data));
107            } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
108    
109      return RESPONSE_OK;          return analyze_response(conn, ibuf.data);
110  }  }
111    
112    
113  /*  /*
114   * Process the data that server sent due to IMAP CAPABILITY client request.   * Process the data that server sent due to IMAP CAPABILITY client request.
115   */   */
116  int capability_response(unsigned int tag)  int
117    response_capability(connection_t * conn, unsigned int tag)
118    {
119    
120            buffer_reset(&ibuf);
121    
122            do {
123                    buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
124                    receive_response(conn, ibuf.data + strlen(ibuf.data));
125                    response_bye(ibuf.data);
126            } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
127    
128            if (opts.force_protocol == PROTOCOL_NONE) {
129                    if (strcasestr(ibuf.data, "IMAP4rev1"))
130                            conn->proto = PROTOCOL_IMAP4REV1;
131                    else if (strcasestr(ibuf.data, "IMAP4"))
132                            conn->proto = PROTOCOL_IMAP4;
133                    else {
134                            error("server supports neither the IMAP4rev1 nor the "
135                                "IMAP4 protocol\n");
136                            return -2;
137                    }
138            } else
139                    conn->proto = opts.force_protocol;
140    
141            if (strcasestr(ibuf.data, "NAMESPACE"))
142                    conn->caps |= CAPABILITY_NAMESPACE;
143    #ifdef CRAM_MD5
144            if (strcasestr(ibuf.data, "AUTH=CRAM-MD5"))
145                    conn->caps |= CAPABILITY_CRAMMD5;
146    #endif
147    #ifdef SSL_TLS
148            if (strcasestr(ibuf.data, "STARTTLS"))
149                    conn->caps |= CAPABILITY_STARTTLS;
150    #endif
151            return analyze_response(conn, ibuf.data);
152    }
153    
154    
155    #ifdef CRAM_MD5
156    /*
157     * Process the data that server sent due to IMAP AUTHENTICATE client request.
158     */
159    int
160    response_authenticate(connection_t * conn, unsigned int tag, unsigned char **cont)
161  {  {
162      int r;          int i;
163      char buf[RESPONSE_BUF];          char *c;
164    
165      do          buffer_reset(&ibuf);
166          r = receive_response(buf);  
167      while (!strcasestr(buf, ultostr(tag, 16)));          do {
168                    buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
169      if (!strcasestr(buf, "IMAP4rev1")) {                  receive_response(conn, ibuf.data + strlen(ibuf.data));
170          error("imapfilter: server does not support IMAP4rev1 protocol\n");                  response_bye(ibuf.data);
171          return -2;          } while (strlen(ibuf.data) == RESPONSE_BUF &&
172      }              !strcasestr(ibuf.data, ultostr(tag, 16)));
173      return r;  
174            if (cont != NULL && ibuf.data[0] == '+' && ibuf.data[1] == ' ') {
175                    c = *cont = (unsigned char *)xmalloc(strlen(ibuf.data) + 1);
176    
177                    for (i = 2; ibuf.data[i] != '\r'; i++)
178                            *c++ = ibuf.data[i];
179    
180                    *c = '\0';
181            }
182            return analyze_response(conn, ibuf.data);
183    }
184    #endif
185    
186    
187    /*
188     * Process the data that server sent due to IMAP NAMESPACE client request.
189     */
190    int
191    response_namespace(connection_t * conn, unsigned int tag)
192    {
193            char *c, *d;
194    
195            buffer_reset(&ibuf);
196    
197            do {
198                    buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
199                    receive_response(conn, ibuf.data + strlen(ibuf.data));
200                    response_bye(ibuf.data);
201            } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
202    
203            if ((c = strcasestr(ibuf.data, "* NAMESPACE"))) {
204                    c += 12;
205                    if (strncasecmp(c, "NIL", 3)) {
206                            c = strchr(c, '"') + 1;
207                            d = strchr(c, '"') + 1;
208    
209                            strncat(conn->ns.prefix, c, d - c - 1);
210                            conn->ns.delim = *(strchr(d, '"') + 1);
211                    }
212            }
213            debug("namespace (%s): '%s' '%c'\n",
214                (conn == &connpri ? "primary" : "auxiliary"), conn->ns.prefix,
215                conn->ns.delim);
216            return analyze_response(conn, ibuf.data);
217  }  }
218    
219    
220  /*  /*
221   * Process the data that server sent due to IMAP STATUS client request.   * Process the data that server sent due to IMAP STATUS client request.
222   */   */
223  int status_response(unsigned int tag)  int
224    response_status(connection_t * conn, unsigned int tag, char *mbox)
225  {  {
226      int r;          int r;
227      char buf[RESPONSE_BUF];          unsigned int exists, recent, unseen;
228      unsigned int exist, recent, unseen;          char *c;
229      char *c;  
230            exists = recent = unseen = 0;
     exist = recent = unseen = 0;  
   
     do  
         r = receive_response(buf);  
     while (!strcasestr(buf, ultostr(tag, 16)));  
   
     if ((c = strcasestr(buf, "MESSAGES"))) {  
         c += 9;  
         exist = strtoul(c, NULL, 10);  
     }  
     if ((c = strcasestr(buf, "RECENT"))) {  
         c += 7;  
         recent = strtoul(c, NULL, 10);  
     }  
     if ((c = strcasestr(buf, "UNSEEN"))) {  
         c += 7;  
         unseen = strtoul(c, NULL, 10);  
     }  
     if (!exist) {  
         info("No messages ");  
         return -2;  
     }  
     info("%d message%s, %d recent, %d unseen, ", exist, plural(exist),  
          recent, unseen);  
231    
232      return r;          buffer_reset(&ibuf);
233    
234            do {
235                    buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
236                    receive_response(conn, ibuf.data + strlen(ibuf.data));
237                    response_bye(ibuf.data);
238            } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
239    
240            r = analyze_response(conn, ibuf.data);
241    
242            if (r == RESPONSE_NO)
243                    return -2;
244    
245            if ((c = strcasestr(ibuf.data, "MESSAGES"))) {
246                    c += 9;
247                    exists = strtoul(c, NULL, 10);
248            }
249            if (exists == 0) {
250                    info("No messages in mailbox \"%s\".\n", mbox);
251                    return -2;
252            }
253            if ((c = strcasestr(ibuf.data, "RECENT"))) {
254                    c += 7;
255                    recent = strtoul(c, NULL, 10);
256            }
257            if ((c = strcasestr(ibuf.data, "UNSEEN"))) {
258                    c += 7;
259                    unseen = strtoul(c, NULL, 10);
260            }
261            info("%d message%s, %d recent, %d unseen, in mailbox \"%s\".\n",
262                exists, plural(exists), recent, unseen, mbox);
263    
264            return r;
265    }
266    
267    
268    /*
269     * Process the data that server sent due to IMAP EXAMINE client request.
270     */
271    int
272    response_examine(connection_t * conn, unsigned int tag, char *mbox)
273    {
274            int r;
275            unsigned int exists, recent, unseen;
276            char *c;
277    
278            exists = recent = unseen = 0;
279    
280            buffer_reset(&ibuf);
281    
282            do {
283                    buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
284                    receive_response(conn, ibuf.data + strlen(ibuf.data));
285                    response_bye(ibuf.data);
286            } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
287    
288            r = analyze_response(conn, ibuf.data);
289    
290            if (r == RESPONSE_NO)
291                    return -2;
292    
293            if ((c = strcasestr(ibuf.data, "EXISTS"))) {
294                    while (--c >= ibuf.data && *c != '*');
295                    c++;
296                    exists = strtoul(c, NULL, 10);
297            }
298            if (exists == 0) {
299                    info("No messages in mailbox \"%s\".\n", mbox);
300                    return -2;
301            }
302            if ((c = strcasestr(ibuf.data, "RECENT"))) {
303                    while (--c >= ibuf.data && *c != '*');
304                    c++;
305                    recent = strtoul(c, NULL, 10);
306            }
307            if ((c = strcasestr(ibuf.data, "UNSEEN"))) {
308                    c += 7;
309                    unseen = strtoul(c, NULL, 10);
310                    info("%d message%s, %d recent, %d unseen, in mailbox \"%s\".\n",
311                        exists, plural(exists), recent, unseen, mbox);
312            } else
313                    info("%d message%s, %d recent, in mailbox \"%s\".\n", exists,
314                        plural(exists), recent, mbox);
315    
316            return r;
317  }  }
318    
319    
320  /*  /*
321   * Process the data that server sent due to IMAP SELECT client request.   * Process the data that server sent due to IMAP SELECT client request.
322   */   */
323  int select_response(unsigned int tag)  int
324    response_select(connection_t * conn, unsigned int tag)
325  {  {
     int r;  
     char buf[RESPONSE_BUF];  
326    
327      do          buffer_reset(&ibuf);
328          r = receive_response(buf);  
329      while (!strcasestr(buf, ultostr(tag, 16)));          do {
330                    buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
331                    receive_response(conn, ibuf.data + strlen(ibuf.data));
332                    response_bye(ibuf.data);
333            } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
334    
335      if (strcasestr(buf, "[READ-ONLY]"))          if (strcasestr(ibuf.data, "[READ-ONLY]"))
336          return RESPONSE_READONLY;                  return RESPONSE_READONLY;
337    
338      return r;          return analyze_response(conn, ibuf.data);
339  }  }
340    
341    
342  /*  /*
343   * Process the data that server sent due to IMAP SEARCH client request.   * Process the data that server sent due to IMAP SEARCH client request.
344   */   */
345  int search_response(unsigned int tag, char *mesgs)  int
346    response_search(connection_t * conn, unsigned int tag, char **mesgs)
347  {  {
348      int r;          char *c, *m;
349      char buf[RESPONSE_BUF];          unsigned int blen;
350      char *c, *m = mesgs;  
351            buffer_reset(&ibuf);
352      do  
353          r = receive_response(buf);          do {
354      while (!strcasestr(buf, ultostr(tag, 16)));                  buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
355                    receive_response(conn, ibuf.data + strlen(ibuf.data));
356      if ((c = strcasestr(buf, "SEARCH "))) {                  response_bye(ibuf.data);
357          c += 7;          } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
358          while (m - mesgs < SEARCH_MESSAGES_BUF && (isdigit(*c) || *c == ' '))  
359              *(m++) = *(c++);          if ((c = strcasestr(ibuf.data, "* SEARCH "))) {
360          if (m - mesgs == SEARCH_MESSAGES_BUF)                  blen = strlen(ibuf.data);
361              *(strrchr(mesgs, ' ')) = 0;  
362          else                  m = *mesgs = (char *)xmalloc(blen + 1);
363              *m = 0;  
364      }                  c += 9;
365        
366      return r;                  while (*c != '\0' && (isdigit(*c) || *c == ' '))
367                            *(m++) = *(c++);
368    
369                    *m = 0;
370            }
371            return analyze_response(conn, ibuf.data);
372  }  }
373    
374    
375  /*  /*
376   * Process the data that server sent due to IMAP FETCH client request.   * Process the data that server sent due to IMAP FETCH client request.
377   */   */
378  int fetch_response(unsigned int tag)  int
379    response_fetch(connection_t * conn, unsigned int tag, int reset, char *fetch)
380  {  {
381      int r, s, i;          unsigned int i;
382      char buf[RESPONSE_BUF];          static unsigned int s;
383      char *pos;          char *b;
384      char headers[HEADERS_BUF];  
385            if (reset) {
386                    s = 0;
387                    return 0;
388            }
389            i = 0;
390    
391      headers[0] = 0;          buffer_reset(&ibuf);
392    
393      do          do {
394          r = receive_response(buf);                  buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
395      while (!strcasestr(buf, ultostr(tag, 16)));                  receive_response(conn, ibuf.data + strlen(ibuf.data));
396                    response_bye(ibuf.data);
397            } while (strlen(ibuf.data) < RESPONSE_BUF &&
398                !strcasestr(ibuf.data, ultostr(tag, 16)));
399    
400            b = ibuf.data;
401    
402            if (s == 0) {
403                    if ((b = strstr(b, "}\r\n"))) {
404                            while (b - ibuf.data > 0)
405                                    if (*--b == '{')
406                                            break;
407                            s = atoi(++b) - 2;
408                            b = strchr(b, '}');
409                            b += 3;
410                    } else {
411                            return RESPONSE_NULLBODY;       /* Null body. */
412                    }
413            }
414            while (*b != '\0' && s-- != 0)
415                    fetch[i++] = *(b++);
416    
417      pos = buf;          fetch[i] = '\0';
418    
419      while ((pos = strchr(pos, '{'))) {          return analyze_response(conn, ibuf.data);
420          s = atoi(pos + 1);  }
         pos = strchr(pos, '}');  
421    
         for (i = 0; i < HEADERS_BUF - 1 && i < s - 2; i++)  
             headers[i] = *(pos + 3 + i);  
422    
423          headers[i] = 0;  /*
424     * Process the data that server sent due to IMAP FETCH FAST client request.
425     */
426    int
427    response_fetchfast(connection_t * conn, char **flags, char **date,
428        unsigned int *size, unsigned int tag)
429    {
430            char *c, *m;
431            unsigned int blen;
432    
433          if (*headers) {          *size = 0;
434              if (options & OPTION_HEADERS)  
435                  info("%s\n", headers);          buffer_reset(&ibuf);
436              log_info(LOG_WRITE, headers);  
437          } else          do {
438              log_info(LOG_WRITE, NULL);                  buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
439      }                  receive_response(conn, ibuf.data + strlen(ibuf.data));
440                    response_bye(ibuf.data);
441            } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
442    
443            if ((c = strcasestr(ibuf.data, "FETCH (FLAGS ("))) {
444                    blen = strlen(ibuf.data);
445    
446                    m = *flags = (char *)xmalloc(blen + 1);
447    
448                    c += 14;
449    
450                    while (*c != '\0' && *c != ')') {
451                            /* The \Recent flag can not be altered by the client. */
452                            if (*c == '\\') {
453                                    if (strcasestr(c - 1, "(\\Recent)") ||
454                                        strcasestr(c - 1, " \\Recent)"))
455                                            break;
456                                    else if (strcasestr(c, "\\Recent "))
457                                            c += 8;
458                            }
459                            *(m++) = *(c++);
460                    }
461    
462                    *m = 0;
463            }
464            if ((c = strcasestr(ibuf.data, " INTERNALDATE \""))) {
465                    blen = strlen(ibuf.data);
466    
467      return r;                  m = *date = (char *)xmalloc(blen + 1);
468    
469                    c += 15;
470    
471                    while (*c != '\0' && *c != '"')
472                            *(m++) = *(c++);
473    
474                    *m = 0;
475            }
476            if ((c = strcasestr(ibuf.data, " RFC822.SIZE "))) {
477                    c += 13;
478                    *size = strtoul(c, NULL, 10);
479            }
480            return analyze_response(conn, ibuf.data);
481  }  }
482    
483    
484  /*  /*
485   * Process the data that server sent due to IMAP COPY client request.   * Process the data that server sent due to IMAP APPEND client request.
486   */   */
487  int copy_response(unsigned int tag)  int
488    response_append(connection_t * conn, unsigned int tag)
489  {  {
490      int r;          int r;
491      char buf[RESPONSE_BUF];  
492            r = RESPONSE_OK;
493    
494      do          buffer_reset(&ibuf);
         r = receive_response(buf);  
     while (!strcasestr(buf, ultostr(tag, 16)));  
495    
496      if (r == RESPONSE_NO && strcasestr(buf, "[TRYCREATE]"))          do {
497          return RESPONSE_TRYCREATE;                  buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
498                    receive_response(conn, ibuf.data + strlen(ibuf.data));
499                    response_bye(ibuf.data);
500            } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
501    
502      return RESPONSE_OK;          if ((r = analyze_response(conn, ibuf.data)) == RESPONSE_NO &&
503                strcasestr(ibuf.data, "[TRYCREATE]"))
504                    return RESPONSE_TRYCREATE;
505    
506            return r;
507  }  }
508    
509    
510  /*  /*
511   * Check if response of server to client's request was succesfully   * Process the data that server sent due to IMAP COPY client request.
  * delivered or there was some kind of error.  
512   */   */
513  int analyze_response(char *buf)  int
514    response_copy(connection_t * conn, unsigned int tag)
515  {  {
516      int r = RESPONSE_OK;          int r;
     regex_t creg;  
     regmatch_t match[3];  
     const char *reg = "[[:xdigit:]]{6,6} ((OK|NO|BAD)[[:print:]]*)\r\n";  
     char result[RESULT_BUF];  
517    
518      result[0] = 0;          r = RESPONSE_OK;
519    
520      regcomp(&creg, reg, REG_EXTENDED | REG_ICASE);          buffer_reset(&ibuf);
521    
522            do {
523                    buffer_check(&ibuf, strlen(ibuf.data) + RESPONSE_BUF);
524                    receive_response(conn, ibuf.data + strlen(ibuf.data));
525                    response_bye(ibuf.data);
526            } while (!strcasestr(ibuf.data, ultostr(tag, 16)));
527    
528            if ((r = analyze_response(conn, ibuf.data)) == RESPONSE_NO &&
529                strcasestr(ibuf.data, "[TRYCREATE]"))
530                    return RESPONSE_TRYCREATE;
531    
532            return r;
533    }
534    
     if (!regexec(&creg, buf, 3, match, 0)) {  
         strncat(result, buf + match[1].rm_so,  
                 min(match[1].rm_eo - match[1].rm_so, RESULT_BUF - 1));  
535    
536          if (!strncasecmp(buf + match[2].rm_so, "NO", 2))  /*
537              r = RESPONSE_NO;   * Check if response of server to client's request was succesfully
538          else if (!strncasecmp(buf + match[2].rm_so, "BAD", 3))   * delivered or there was some kind of error.
539              r = RESPONSE_BAD;   */
540    int
541    analyze_response(connection_t * conn, char *buf)
542    {
543            int r;
544            regex_t creg;
545            regmatch_t match[3];
546            const char *reg;
547            char result[RESULT_BUF];
548    
549            r = RESPONSE_OK;
550            reg = "[[:xdigit:]]{4,4} ((OK|NO|BAD)[[:print:]]*)\r\n";
551            result[0] = '\0';
552    
553            regcomp(&creg, reg, REG_EXTENDED | REG_ICASE);
554    
555            if (!regexec(&creg, buf, 3, match, 0)) {
556                    strncat(result, buf + match[1].rm_so,
557                        min(match[1].rm_eo - match[1].rm_so, RESULT_BUF - 1));
558    
559                    if (!strncasecmp(buf + match[2].rm_so, "NO", 2))
560                            r = RESPONSE_NO;
561                    else if (!strncasecmp(buf + match[2].rm_so, "BAD", 3))
562                            r = RESPONSE_BAD;
563    
564                    verbose("%s: %s", (conn == &connpri ? "S" : "s"),
565                        buf + match[0].rm_so);
566            } else
567                    r = RESPONSE_NONE;
568    
569          verbose("Server response: %s\n", result);          regfree(&creg);
     }  
     regfree(&creg);  
570    
571      return r;          return r;
572  }  }
Legend:
Removed from v.1.9.2.2  
changed lines
  Added in v.1.53
webmaster@linux.gr
 ViewVC Help
Powered by ViewVC 1.1.26