uschar * string_dequote(const uschar **sptr) { const uschar *s = *sptr; uschar *t, *yield; /* First find the end of the string */ if (*s != '\"') { while (*s != 0 && !isspace(*s)) s++; } else { s++; while (*s != 0 && *s != '\"') { if (*s == '\\') (void)string_interpret_escape(&s); s++; } if (*s != 0) s++; } /* Get enough store to copy into */ t = yield = store_get(s - *sptr + 1); s = *sptr; /* Do the copy */ if (*s != '\"') { while (*s != 0 && !isspace(*s)) *t++ = *s++; } else { s++; while (*s != 0 && *s != '\"') { if (*s == '\\') *t++ = string_interpret_escape(&s); else *t++ = *s; s++; } if (*s != 0) s++; } /* Update the pointer and return the terminated copy */ *sptr = s; *t = 0; return yield; }
uschar * string_unprinting(uschar *s) { uschar *p, *q, *r, *ss; int len, off; p = Ustrchr(s, '\\'); if (!p) return s; len = Ustrlen(s) + 1; ss = store_get(len); q = ss; off = p - s; if (off) { memcpy(q, s, off); q += off; } while (*p) { if (*p == '\\') { *q++ = string_interpret_escape((const uschar **)&p); p++; } else { r = Ustrchr(p, '\\'); if (!r) { off = Ustrlen(p); memcpy(q, p, off); p += off; q += off; break; } else { off = r - p; memcpy(q, p, off); q += off; p = r; } } } *q = '\0'; return ss; }
static int internal_lsearch_find(void *handle, uschar *filename, uschar *keystring, int length, uschar **result, uschar **errmsg, int type) { FILE *f = (FILE *)handle; BOOL last_was_eol = TRUE; BOOL this_is_eol = TRUE; int old_pool = store_pool; void *reset_point = NULL; uschar buffer[4096]; /* Wildcard searches may use up some store, because of expansions. We don't want them to fill up our search store. What we do is set the pool to the main pool and get a point to reset to later. Wildcard searches could also issue lookups, but internal_search_find will take care of that, and the cache will be safely stored in the search pool again. */ if(type == LSEARCH_WILD || type == LSEARCH_NWILD) { store_pool = POOL_MAIN; reset_point = store_get(0); } filename = filename; /* Keep picky compilers happy */ errmsg = errmsg; rewind(f); for (last_was_eol = TRUE; Ufgets(buffer, sizeof(buffer), f) != NULL; last_was_eol = this_is_eol) { int ptr, size; int p = Ustrlen(buffer); int linekeylength; BOOL this_is_comment; uschar *yield; uschar *s = buffer; /* Check whether this the final segment of a line. If it follows an incomplete part-line, skip it. */ this_is_eol = p > 0 && buffer[p-1] == '\n'; if (!last_was_eol) continue; /* We now have the start of a physical line. If this is a final line segment, remove trailing white space. */ if (this_is_eol) { while (p > 0 && isspace((uschar)buffer[p-1])) p--; buffer[p] = 0; } /* If the buffer is empty it might be (a) a complete empty line, or (b) the start of a line that begins with so much white space that it doesn't all fit in the buffer. In both cases we want to skip the entire physical line. If the buffer begins with # it is a comment line; if it begins with white space it is a logical continuation; again, we want to skip the entire physical line. */ if (buffer[0] == 0 || buffer[0] == '#' || isspace(buffer[0])) continue; /* We assume that they key will fit in the buffer. If the key starts with ", read it as a quoted string. We don't use string_dequote() because that uses new store for the result, and we may be doing this many times in a long file. We know that the dequoted string must be shorter than the original, because we are removing the quotes, and also any escape sequences always turn two or more characters into one character. Therefore, we can store the new string in the same buffer. */ if (*s == '\"') { uschar *t = s++; while (*s != 0 && *s != '\"') { if (*s == '\\') *t++ = string_interpret_escape(&s); else *t++ = *s; s++; } if (*s != 0) s++; /* Past terminating " */ linekeylength = t - buffer; } /* Otherwise it is terminated by a colon or white space */ else { while (*s != 0 && *s != ':' && !isspace(*s)) s++; linekeylength = s - buffer; } /* The matching test depends on which kind of lsearch we are doing */ switch(type) { /* A plain lsearch treats each key as a literal */ case LSEARCH_PLAIN: if (linekeylength != length || strncmpic(buffer, keystring, length) != 0) continue; break; /* Key matched */ /* A wild lsearch treats each key as a possible wildcarded string; no expansion is done for nwildlsearch. */ case LSEARCH_WILD: case LSEARCH_NWILD: { int rc; int save = buffer[linekeylength]; uschar *list = buffer; buffer[linekeylength] = 0; rc = match_isinlist(keystring, &list, UCHAR_MAX+1, /* Single-item list */ NULL, /* No anchor */ NULL, /* No caching */ MCL_STRING + ((type == LSEARCH_WILD)? 0:MCL_NOEXPAND), TRUE, /* Caseless */ NULL); buffer[linekeylength] = save; if (rc == FAIL) continue; if (rc == DEFER) return DEFER; } /* The key has matched. If the search involved a regular expression, it might have caused numerical variables to be set. However, their values will be in the wrong storage pool for external use. Copying them to the standard pool is not feasible because of the caching of lookup results - a repeated lookup will not match the regular expression again. Therefore, we flatten all numeric variables at this point. */ expand_nmax = -1; break; /* Compare an ip address against a list of network/ip addresses. We have to allow for the "*" case specially. */ case LSEARCH_IP: if (linekeylength == 1 && buffer[0] == '*') { if (length != 1 || keystring[0] != '*') continue; } else if (length == 1 && keystring[0] == '*') continue; else { int maskoffset; int save = buffer[linekeylength]; buffer[linekeylength] = 0; if (string_is_ip_address(buffer, &maskoffset) == 0 || !host_is_in_net(keystring, buffer, maskoffset)) continue; buffer[linekeylength] = save; } break; /* Key matched */ } /* The key has matched. Skip spaces after the key, and allow an optional colon after the spaces. This is an odd specification, but it's for compatibility. */ while (isspace((uschar)*s)) s++; if (*s == ':') { s++; while (isspace((uschar)*s)) s++; } /* Reset dynamic store, if we need to, and revert to the search pool */ if (reset_point != NULL) { store_reset(reset_point); store_pool = old_pool; } /* Now we want to build the result string to contain the data. There can be two kinds of continuation: (a) the physical line may not all have fitted into the buffer, and (b) there may be logical continuation lines, for which we must convert all leading white space into a single blank. Initialize, and copy the first segment of data. */ this_is_comment = FALSE; size = 100; ptr = 0; yield = store_get(size); if (*s != 0) yield = string_cat(yield, &size, &ptr, s, Ustrlen(s)); /* Now handle continuations */ for (last_was_eol = this_is_eol; Ufgets(buffer, sizeof(buffer), f) != NULL; last_was_eol = this_is_eol) { s = buffer; p = Ustrlen(buffer); this_is_eol = p > 0 && buffer[p-1] == '\n'; /* Remove trailing white space from a physical line end */ if (this_is_eol) { while (p > 0 && isspace((uschar)buffer[p-1])) p--; buffer[p] = 0; } /* If this is not a physical line continuation, skip it entirely if it's empty or starts with #. Otherwise, break the loop if it doesn't start with white space. Otherwise, replace leading white space with a single blank. */ if (last_was_eol) { this_is_comment = (this_is_comment || (buffer[0] == 0 || buffer[0] == '#')); if (this_is_comment) continue; if (!isspace((uschar)buffer[0])) break; while (isspace((uschar)*s)) s++; *(--s) = ' '; } if (this_is_comment) continue; /* Join a physical or logical line continuation onto the result string. */ yield = string_cat(yield, &size, &ptr, s, Ustrlen(s)); } yield[ptr] = 0; store_reset(yield + ptr + 1); *result = yield; return OK; } /* Reset dynamic store, if we need to */ if (reset_point != NULL) { store_reset(reset_point); store_pool = old_pool; } return FAIL; }