mirror of
https://github.com/nmap/nmap.git
synced 2026-10-24 04:43:03 +00:00
Filespace code cleanup.
- Removed dead code. - Fixed style, improved consistency. - Replaced FILESPACE_LENGTH and FILESPACE_STR macros by identical static inline functions. - Made fs_cat() a regular function. There's no actual benefit of having it inlined.
This commit is contained in:
henri
parent
89f69c40e7
commit
2774c8cce6
6 changed files with 74 additions and 167 deletions
|
|
@ -78,47 +78,6 @@ int filespace_init(struct filespace *fs, int initial_size) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* Prepend an n-char string to a filespace */
|
||||
int fs_prepend(char *str, int len, struct filespace *fs){
|
||||
char *tmpstr;
|
||||
|
||||
if (len < 0)
|
||||
return -1;
|
||||
|
||||
if (len == 0)
|
||||
return 0;
|
||||
|
||||
if (fs->current_alloc - fs->current_size < len + 2) {
|
||||
fs->current_alloc = (int)(fs->current_alloc * 1.4 + 1);
|
||||
fs->current_alloc += 100 + len;
|
||||
|
||||
tmpstr = (char *)safe_malloc(fs->current_alloc);
|
||||
memcpy(tmpstr, fs->str, fs->current_size);
|
||||
|
||||
fs->pos = (fs->pos - fs->str) + tmpstr;
|
||||
if (fs->str)
|
||||
free(fs->str);
|
||||
|
||||
fs->str = tmpstr;
|
||||
}
|
||||
if (fs->current_size > 0)
|
||||
memmove(fs->str + len, fs->str, fs->current_size);
|
||||
memcpy(fs->str, str, len);
|
||||
|
||||
fs->current_size += len;
|
||||
fs->str[fs->current_size] = '\0';
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Used when you want to start over with a filespace you have been using (it
|
||||
* sets the length to zero and the pointers to the beginning of memory , etc */
|
||||
int fs_clear(struct filespace *fs) {
|
||||
fs->current_size = 0;
|
||||
fs->pos = fs->str;
|
||||
fs->str[0] = '\0'; /* Not necessary, possible help with debugging */
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fs_free(struct filespace *fs) {
|
||||
if (fs->str)
|
||||
free(fs->str);
|
||||
|
|
@ -128,3 +87,39 @@ int fs_free(struct filespace *fs) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* Concatenate a string to the end of a filespace */
|
||||
int fs_cat(struct filespace *fs, const char *str, int len) {
|
||||
if (len < 0)
|
||||
return -1;
|
||||
|
||||
if (len == 0)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
printf("fscat: current_alloc=%d; current_size=%d; len=%d\n",
|
||||
fs->current_alloc, fs->current_size, len);
|
||||
*/
|
||||
|
||||
if (fs->current_alloc - fs->current_size < len + 2) {
|
||||
char *tmpstr;
|
||||
|
||||
fs->current_alloc = (int)(fs->current_alloc * 1.4 + 1);
|
||||
fs->current_alloc += 100 + len;
|
||||
|
||||
tmpstr = (char *)safe_malloc(fs->current_alloc);
|
||||
memcpy(tmpstr, fs->str, fs->current_size);
|
||||
|
||||
fs->pos = (fs->pos - fs->str) + tmpstr;
|
||||
|
||||
if (fs->str)
|
||||
free(fs->str);
|
||||
|
||||
fs->str = tmpstr;
|
||||
}
|
||||
memcpy(fs->str + fs->current_size, str, len);
|
||||
|
||||
fs->current_size += len;
|
||||
fs->str[fs->current_size] = '\0';
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -77,8 +77,6 @@
|
|||
#include <strings.h>
|
||||
#endif
|
||||
|
||||
#define FILESPACE_LENGTH(fs) ((fs)->current_size)
|
||||
#define FILESPACE_STR(fs) ((fs)->str)
|
||||
|
||||
struct filespace {
|
||||
int current_size;
|
||||
|
|
@ -89,107 +87,21 @@ struct filespace {
|
|||
char *str;
|
||||
};
|
||||
|
||||
/* If you want to express a length, use fscat() */
|
||||
static inline int fs_rputs(const char *str, struct filespace *fs) {
|
||||
char *new_str;
|
||||
int len;
|
||||
|
||||
len = (int)strlen(str);
|
||||
|
||||
if (len + fs->current_size + 1 > fs->current_alloc) {
|
||||
fs->current_alloc = MAX(fs->current_size * 2, fs->current_size + len + 1000);
|
||||
|
||||
new_str = (char *)safe_malloc(fs->current_alloc);
|
||||
memcpy(new_str, fs->str, fs->current_size);
|
||||
|
||||
fs->pos = (fs->pos - fs->str) + new_str;
|
||||
if (fs->str)
|
||||
free(fs->str);
|
||||
fs->str = new_str;
|
||||
}
|
||||
memcpy(fs->str + fs->current_size, str, len);
|
||||
fs->current_size += len;
|
||||
fs->str[fs->current_size] = '\0';
|
||||
|
||||
return 0;
|
||||
static inline int fs_length(const struct filespace *fs) {
|
||||
return fs->current_size;
|
||||
}
|
||||
|
||||
|
||||
static inline int fs_rvputs(struct filespace *fs,...) {
|
||||
va_list args;
|
||||
const char *x;
|
||||
|
||||
va_start(args, fs);
|
||||
for (;;) {
|
||||
x = va_arg(args, const char *);
|
||||
if (x == NULL)
|
||||
break;
|
||||
|
||||
if (fs_rputs(x,fs) == -1) {
|
||||
va_end(args);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
va_end(args);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Concatenate a string to the end of a filespace */
|
||||
static inline int fscat(struct filespace *fs, const char *str, int len) {
|
||||
char *tmpstr;
|
||||
|
||||
if (len < 0)
|
||||
return -1;
|
||||
if (len == 0)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
printf("fscat: current_alloc=%d; current_size=%d; len=%d\n", fs->current_alloc, fs->current_size, len);
|
||||
*/
|
||||
|
||||
if (fs->current_alloc - fs->current_size < len + 2) {
|
||||
fs->current_alloc = (int) (fs->current_alloc * 1.4 + 1 );
|
||||
fs->current_alloc += 100 + len;
|
||||
|
||||
tmpstr = (char *)safe_malloc(fs->current_alloc);
|
||||
memcpy(tmpstr, fs->str, fs->current_size);
|
||||
|
||||
fs->pos = (fs->pos - fs->str) + tmpstr;
|
||||
if (fs->str) free(fs->str);
|
||||
fs->str = tmpstr;
|
||||
}
|
||||
memcpy(fs->str + fs->current_size, str, len);
|
||||
|
||||
fs->current_size += len;
|
||||
fs->str[fs->current_size] = '\0';
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int fs_rputc(int ch, struct filespace *fs) {
|
||||
char s[2];
|
||||
|
||||
if (fs->current_size + 2 <= fs->current_alloc) {
|
||||
fs->str[fs->current_size] = ch;
|
||||
fs->current_size++;
|
||||
fs->str[fs->current_size] = '\0';
|
||||
} else {
|
||||
/* otherwise we use the ueber-technique of letting fscat handle it ... umm
|
||||
* actually I don't know why we don't do this in all cases ... */
|
||||
s[0] = ch;
|
||||
s[1] = '\0';
|
||||
fscat(fs, s, 1);
|
||||
}
|
||||
return 0;
|
||||
static inline char * fs_str(const struct filespace *fs) {
|
||||
return fs->str;
|
||||
}
|
||||
|
||||
|
||||
int filespace_init(struct filespace *fs, int initial_size);
|
||||
|
||||
int fs_prepend(char *str, int len, struct filespace *fs);
|
||||
|
||||
int fs_clear(struct filespace *fs);
|
||||
|
||||
int fs_free(struct filespace *fs);
|
||||
|
||||
int fs_cat(struct filespace *fs, const char *str, int len);
|
||||
|
||||
#endif /* FILESPACE_H */
|
||||
|
||||
|
|
|
|||
|
|
@ -512,8 +512,8 @@ void handle_write_result(mspool *ms, msevent *nse, enum nse_status status) {
|
|||
nse->event_done = 1;
|
||||
nse->status = status;
|
||||
} else if (status == NSE_STATUS_SUCCESS) {
|
||||
str = FILESPACE_STR(&nse->iobuf) + nse->writeinfo.written_so_far;
|
||||
bytesleft = FILESPACE_LENGTH(&nse->iobuf) - nse->writeinfo.written_so_far;
|
||||
str = fs_str(&nse->iobuf) + nse->writeinfo.written_so_far;
|
||||
bytesleft = fs_length(&nse->iobuf) - nse->writeinfo.written_so_far;
|
||||
if (nse->writeinfo.written_so_far > 0)
|
||||
assert(bytesleft > 0);
|
||||
#if HAVE_OPENSSL
|
||||
|
|
@ -601,7 +601,7 @@ static int do_actual_read(mspool *ms, msevent *nse) {
|
|||
msiod *iod = nse->iod;
|
||||
int err = 0;
|
||||
int max_chunk = NSOCK_READ_CHUNK_SIZE;
|
||||
int startlen = FILESPACE_LENGTH(&nse->iobuf);
|
||||
int startlen = fs_length(&nse->iobuf);
|
||||
|
||||
if (nse->readinfo.read_type == NSOCK_READBYTES)
|
||||
max_chunk = nse->readinfo.num;
|
||||
|
|
@ -634,7 +634,7 @@ static int do_actual_read(mspool *ms, msevent *nse) {
|
|||
iod->peerlen = peerlen;
|
||||
}
|
||||
if (buflen > 0) {
|
||||
if (fscat(&nse->iobuf, buf, buflen) == -1) {
|
||||
if (fs_cat(&nse->iobuf, buf, buflen) == -1) {
|
||||
nse->event_done = 1;
|
||||
nse->status = NSE_STATUS_ERROR;
|
||||
nse->errnum = ENOMEM;
|
||||
|
|
@ -644,8 +644,8 @@ static int do_actual_read(mspool *ms, msevent *nse) {
|
|||
/* Sometimes a service just spews and spews data. So we return after a
|
||||
* somewhat large amount to avoid monopolizing resources and avoid DOS
|
||||
* attacks. */
|
||||
if (FILESPACE_LENGTH(&nse->iobuf) > max_chunk)
|
||||
return FILESPACE_LENGTH(&nse->iobuf) - startlen;
|
||||
if (fs_length(&nse->iobuf) > max_chunk)
|
||||
return fs_length(&nse->iobuf) - startlen;
|
||||
|
||||
/* No good reason to read again if we we were successful in the read but
|
||||
* didn't fill up the buffer. Especially for UDP, where we want to
|
||||
|
|
@ -653,7 +653,7 @@ static int do_actual_read(mspool *ms, msevent *nse) {
|
|||
* assignment of iod->peer depends on not consolidating more than one
|
||||
* UDP read buffer. */
|
||||
if (buflen > 0 && buflen < sizeof(buf))
|
||||
return FILESPACE_LENGTH(&nse->iobuf) - startlen;
|
||||
return fs_length(&nse->iobuf) - startlen;
|
||||
}
|
||||
} while (buflen > 0 || (buflen == -1 && err == EINTR));
|
||||
|
||||
|
|
@ -670,7 +670,7 @@ static int do_actual_read(mspool *ms, msevent *nse) {
|
|||
/* OpenSSL read */
|
||||
while ((buflen = SSL_read(iod->ssl, buf, sizeof(buf))) > 0) {
|
||||
|
||||
if (fscat(&nse->iobuf, buf, buflen) == -1) {
|
||||
if (fs_cat(&nse->iobuf, buf, buflen) == -1) {
|
||||
nse->event_done = 1;
|
||||
nse->status = NSE_STATUS_ERROR;
|
||||
nse->errnum = ENOMEM;
|
||||
|
|
@ -680,8 +680,8 @@ static int do_actual_read(mspool *ms, msevent *nse) {
|
|||
/* Sometimes a service just spews and spews data. So we return
|
||||
* after a somewhat large amount to avoid monopolizing resources
|
||||
* and avoid DOS attacks. */
|
||||
if (FILESPACE_LENGTH(&nse->iobuf) > max_chunk)
|
||||
return FILESPACE_LENGTH(&nse->iobuf) - startlen;
|
||||
if (fs_length(&nse->iobuf) > max_chunk)
|
||||
return fs_length(&nse->iobuf) - startlen;
|
||||
}
|
||||
|
||||
if (buflen == -1) {
|
||||
|
|
@ -716,16 +716,16 @@ static int do_actual_read(mspool *ms, msevent *nse) {
|
|||
if (buflen == 0) {
|
||||
nse->event_done = 1;
|
||||
nse->eof = 1;
|
||||
if (FILESPACE_LENGTH(&nse->iobuf) > 0) {
|
||||
if (fs_length(&nse->iobuf) > 0) {
|
||||
nse->status = NSE_STATUS_SUCCESS;
|
||||
return FILESPACE_LENGTH(&nse->iobuf) - startlen;
|
||||
return fs_length(&nse->iobuf) - startlen;
|
||||
} else {
|
||||
nse->status = NSE_STATUS_EOF;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return FILESPACE_LENGTH(&nse->iobuf) - startlen;
|
||||
return fs_length(&nse->iobuf) - startlen;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -737,7 +737,7 @@ void handle_read_result(mspool *ms, msevent *nse, enum nse_status status) {
|
|||
|
||||
if (status == NSE_STATUS_TIMEOUT) {
|
||||
nse->event_done = 1;
|
||||
if (FILESPACE_LENGTH(&nse->iobuf) > 0)
|
||||
if (fs_length(&nse->iobuf) > 0)
|
||||
nse->status = NSE_STATUS_SUCCESS;
|
||||
else
|
||||
nse->status = NSE_STATUS_TIMEOUT;
|
||||
|
|
@ -756,7 +756,7 @@ void handle_read_result(mspool *ms, msevent *nse, enum nse_status status) {
|
|||
nse->event_done = 1;
|
||||
break;
|
||||
case NSOCK_READBYTES:
|
||||
if (FILESPACE_LENGTH(&nse->iobuf) >= nse->readinfo.num) {
|
||||
if (fs_length(&nse->iobuf) >= nse->readinfo.num) {
|
||||
nse->status = NSE_STATUS_SUCCESS;
|
||||
nse->event_done = 1;
|
||||
}
|
||||
|
|
@ -765,8 +765,8 @@ void handle_read_result(mspool *ms, msevent *nse, enum nse_status status) {
|
|||
case NSOCK_READLINES:
|
||||
/* Lets count the number of lines we have ... */
|
||||
count = 0;
|
||||
len = FILESPACE_LENGTH(&nse->iobuf) -1;
|
||||
str = FILESPACE_STR(&nse->iobuf);
|
||||
len = fs_length(&nse->iobuf) -1;
|
||||
str = fs_str(&nse->iobuf);
|
||||
for (count=0; len >= 0; len--) {
|
||||
if (str[len] == '\n') {
|
||||
count++;
|
||||
|
|
@ -817,7 +817,7 @@ void handle_pcap_read_result(mspool *ms, msevent *nse, enum nse_status status) {
|
|||
nse->event_done = 1;
|
||||
} else if (status == NSE_STATUS_SUCCESS) {
|
||||
/* check if we already have something read */
|
||||
if (FILESPACE_LENGTH(&(nse->iobuf)) == 0) {
|
||||
if (fs_length(&(nse->iobuf)) == 0) {
|
||||
nse->status = NSE_STATUS_TIMEOUT;
|
||||
nse->event_done = 0;
|
||||
} else {
|
||||
|
|
@ -988,12 +988,12 @@ void process_event(mspool *nsp, gh_list *evlist, msevent *nse, int ev) {
|
|||
|
||||
if (ev & EV_READ) {
|
||||
/* buffer empty? check it! */
|
||||
if (FILESPACE_LENGTH(&(nse->iobuf)) == 0)
|
||||
if (fs_length(&(nse->iobuf)) == 0)
|
||||
do_actual_pcap_read(nse);
|
||||
}
|
||||
|
||||
/* if already received smth */
|
||||
if (FILESPACE_LENGTH(&(nse->iobuf)) > 0)
|
||||
if (fs_length(&(nse->iobuf)) > 0)
|
||||
handle_pcap_read_result(nsp, nse, NSE_STATUS_SUCCESS);
|
||||
|
||||
if (!nse->event_done && nse->timeout.tv_sec && !TIMEVAL_AFTER(nse->timeout, nsock_tod))
|
||||
|
|
|
|||
|
|
@ -115,8 +115,8 @@ char *nse_readbuf(nsock_event nse, int *nbytes) {
|
|||
msevent *me = (msevent *)nse;
|
||||
|
||||
if (nbytes)
|
||||
*nbytes = FILESPACE_LENGTH(&(me->iobuf));
|
||||
return FILESPACE_STR(&(me->iobuf));
|
||||
*nbytes = fs_length(&(me->iobuf));
|
||||
return fs_str(&(me->iobuf));
|
||||
}
|
||||
|
||||
static void first_ev_next(msevent *nse, gh_list_elem **first) {
|
||||
|
|
|
|||
|
|
@ -370,7 +370,7 @@ int do_actual_pcap_read(msevent *nse) {
|
|||
nsock_log_debug_all(nse->iod->nsp, "PCAP %s TEST (IOD #%li) (EID #%li)",
|
||||
__func__, nse->iod->id, nse->id);
|
||||
|
||||
assert( FILESPACE_LENGTH(&(nse->iobuf)) == 0 );
|
||||
assert(fs_length(&(nse->iobuf)) == 0);
|
||||
|
||||
rc = pcap_next_ex(mp->pt, &pkt_header, &pkt_data);
|
||||
switch(rc) {
|
||||
|
|
@ -385,10 +385,10 @@ int do_actual_pcap_read(msevent *nse) {
|
|||
npp.caplen = pkt_header->caplen;
|
||||
npp.packet = pkt_data;
|
||||
|
||||
fscat(&(nse->iobuf), (char *)&npp, sizeof(npp));
|
||||
fscat(&(nse->iobuf), (char *)pkt_data, npp.caplen);
|
||||
n = (nsock_pcap *)FILESPACE_STR(&(nse->iobuf));
|
||||
n->packet = (unsigned char *)FILESPACE_STR(&(nse->iobuf)) + sizeof(npp);
|
||||
fs_cat(&(nse->iobuf), (char *)&npp, sizeof(npp));
|
||||
fs_cat(&(nse->iobuf), (char *)pkt_data, npp.caplen);
|
||||
n = (nsock_pcap *)fs_str(&(nse->iobuf));
|
||||
n->packet = (unsigned char *)fs_str(&(nse->iobuf)) + sizeof(npp);
|
||||
|
||||
nsock_log_debug_all(nse->iod->nsp, "PCAP %s READ (IOD #%li) (EID #%li) size=%i",
|
||||
__func__, nse->iod->id, nse->id, pkt_header->caplen);
|
||||
|
|
@ -416,8 +416,8 @@ void nse_readpcap(nsock_event nsee, const unsigned char **l2_data, size_t *l2_le
|
|||
size_t l2l;
|
||||
size_t l3l;
|
||||
|
||||
nsock_pcap *n = (nsock_pcap *)FILESPACE_STR(&(nse->iobuf));
|
||||
if (FILESPACE_LENGTH(&(nse->iobuf)) < sizeof(nsock_pcap)) {
|
||||
nsock_pcap *n = (nsock_pcap *)fs_str(&(nse->iobuf));
|
||||
if (fs_length(&(nse->iobuf)) < sizeof(nsock_pcap)) {
|
||||
if (l2_data)
|
||||
*l2_data = NULL;
|
||||
if (l2_len)
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ nsock_event_id nsock_sendto(nsock_pool ms_pool, nsock_iod ms_iod, nsock_ev_handl
|
|||
nsock_log_debug(nsp, "Sendto request for %d bytes to IOD #%li EID %li [%s]%s",
|
||||
datalen, nsi->id, nse->id, get_peeraddr_string(nse->iod), displaystr);
|
||||
|
||||
fscat(&nse->iobuf, data, datalen);
|
||||
fs_cat(&nse->iobuf, data, datalen);
|
||||
|
||||
nsp_add_event(nsp, nse);
|
||||
|
||||
|
|
@ -157,7 +157,7 @@ nsock_event_id nsock_write(nsock_pool ms_pool, nsock_iod ms_iod,
|
|||
nsock_log_debug(nsp, "Write request for %d bytes to IOD #%li EID %li (peer unspecified)%s",
|
||||
datalen, nsi->id, nse->id, displaystr);
|
||||
|
||||
fscat(&nse->iobuf, data, datalen);
|
||||
fs_cat(&nse->iobuf, data, datalen);
|
||||
|
||||
nsp_add_event(nsp, nse);
|
||||
|
||||
|
|
@ -209,7 +209,7 @@ nsock_event_id nsock_printf(nsock_pool ms_pool, nsock_iod ms_iod,
|
|||
nse->event_done = 1;
|
||||
nse->status = NSE_STATUS_SUCCESS;
|
||||
} else {
|
||||
fscat(&nse->iobuf, buf2, strlength);
|
||||
fs_cat(&nse->iobuf, buf2, strlength);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue