#include "ntp_fp.h"
#include "ntp_types.h"
+#include <isc/list.h>
+
/*
* recvbuf memory management
*/
*/
#define RX_BUFF_SIZE 1000 /* hail Mary */
+
+typedef struct recvbuf recvbuf_t;
+
struct recvbuf {
- struct recvbuf *next; /* next buffer in chain */
+ ISC_LINK(recvbuf_t) link;
union {
struct sockaddr_storage X_recv_srcadr;
caddr_t X_recv_srcclock;
*/
extern void freerecvbuf P((struct recvbuf *));
-
-extern struct recvbuf * getrecvbufs P((void));
-
/* Get a free buffer (typically used so an async
* read can directly place data into the buffer
*
#include "recvbuff.h"
#include "iosignal.h"
+#include <isc/list.h>
/*
* Memory allocation
*/
-static u_long volatile full_recvbufs; /* number of recvbufs on fulllist */
-static u_long volatile free_recvbufs; /* number of recvbufs on freelist */
-static u_long volatile total_recvbufs; /* total recvbufs currently in use */
+static u_long volatile full_recvbufs; /* number of recvbufs on fulllist */
+static u_long volatile free_recvbufs; /* number of recvbufs on freelist */
+static u_long volatile total_recvbufs; /* total recvbufs currently in use */
static u_long volatile lowater_adds; /* number of times we have added memory */
-static struct recvbuf *volatile freelist; /* free buffers */
-static struct recvbuf *volatile fulllist; /* lifo buffers with data */
-static struct recvbuf *volatile beginlist; /* fifo buffers with data */
+
+static ISC_LIST(recvbuf_t) full_list; /* Currently used recv buffers */
+static ISC_LIST(recvbuf_t) free_list; /* Currently unused buffers */
#if defined(HAVE_IO_COMPLETION_PORT)
}
static void
-initialise_buffer(struct recvbuf *buff)
+initialise_buffer(recvbuf_t *buff)
{
- memset((char *) buff, 0, sizeof(struct recvbuf));
+ memset((char *) buff, 0, sizeof(recvbuf_t));
#if defined HAVE_IO_COMPLETION_PORT
buff->wsabuff.len = RX_BUFF_SIZE;
}
static void
-create_buffers(void)
+create_buffers(int nbufs)
{
- register struct recvbuf *buf;
+ register recvbuf_t *buf;
int i;
- buf = (struct recvbuf *)
- emalloc(RECV_INC*sizeof(struct recvbuf));
- for (i = 0; i < RECV_INC; i++)
+ buf = (recvbuf_t *)
+ emalloc(nbufs*sizeof(recvbuf_t));
+ for (i = 0; i < nbufs; i++)
{
initialise_buffer(buf);
- buf->next = (struct recvbuf *) freelist;
- freelist = buf;
+ ISC_LIST_APPEND(free_list, buf, link);
buf++;
+ free_recvbufs++;
+ total_recvbufs++;
}
-
- free_recvbufs += RECV_INC;
- total_recvbufs += RECV_INC;
lowater_adds++;
}
void
init_recvbuff(int nbufs)
{
- register struct recvbuf *buf;
- int i;
/*
* Init buffer free list and stat counters
*/
- freelist = 0;
-
- buf = (struct recvbuf *)
- emalloc(nbufs*sizeof(struct recvbuf));
- for (i = 0; i < nbufs; i++)
- {
- initialise_buffer(buf);
- buf->next = (struct recvbuf *) freelist;
- freelist = buf;
- buf++;
- }
-
- fulllist = 0;
- free_recvbufs = total_recvbufs = nbufs;
+ ISC_LIST_INIT(full_list);
+ ISC_LIST_INIT(free_list);
+ free_recvbufs = total_recvbufs = 0;
full_recvbufs = lowater_adds = 0;
+ create_buffers(nbufs);
+
#if defined(HAVE_IO_COMPLETION_PORT)
InitializeCriticalSection(&RecvLock);
#endif
}
-
-/*
- * getrecvbufs - get receive buffers which have data in them
- *
- *
- */
-
-struct recvbuf *
-getrecvbufs(void)
-{
- struct recvbuf *rb = NULL; /* nothing has arrived */;
-
- LOCK();
- if (full_recvbufs == 0)
- {
-#ifdef DEBUG
- if (debug > 4)
- printf("getrecvbufs called, no action here\n");
-#endif
- }
- else {
-
- /*
- * Get the fulllist chain and mark it empty
- */
-#ifdef DEBUG
- if (debug > 4)
- printf("getrecvbufs returning %ld buffers\n", full_recvbufs);
-#endif
- rb = beginlist;
- fulllist = 0;
- full_recvbufs = 0;
-
- /*
- * Check to see if we're below the low water mark.
- */
- if (free_recvbufs <= RECV_LOWAT)
- {
- if (total_recvbufs >= RECV_TOOMANY)
- msyslog(LOG_ERR, "too many recvbufs allocated (%ld)",
- total_recvbufs);
- else
- {
- create_buffers();
- }
- }
- }
- UNLOCK();
-
- /*
- * Return the chain
- */
- return rb;
-}
-
/*
* freerecvbuf - make a single recvbuf available for reuse
*/
void
-freerecvbuf(
- struct recvbuf *rb
- )
+freerecvbuf(recvbuf_t *rb)
{
LOCK();
BLOCKIO();
- rb->next = (struct recvbuf *) freelist;
- freelist = rb;
+ ISC_LIST_APPEND(free_list, rb, link);
free_recvbufs++;
UNBLOCKIO();
UNLOCK();
void
-add_full_recv_buffer(
- struct recvbuf *rb
- )
+add_full_recv_buffer(recvbuf_t *rb)
{
LOCK();
- if (full_recvbufs == 0)
- {
- beginlist = rb;
- rb->next = 0;
- }
- else
- {
- rb->next = fulllist->next;
- fulllist->next = rb;
- }
- fulllist = rb;
+ ISC_LIST_APPEND(full_list, rb, link);
full_recvbufs++;
-
UNLOCK();
}
-struct recvbuf *
+recvbuf_t *
get_free_recv_buffer(void)
{
- struct recvbuf * buffer = NULL;
+ recvbuf_t * buffer = NULL;
LOCK();
- if (free_recvbufs <= RECV_LOWAT)
- {
- if (total_recvbufs >= RECV_TOOMANY) {
- msyslog(LOG_ERR, "too many recvbufs allocated (%ld)",
- total_recvbufs);
- }
- else
- {
- create_buffers();
- }
- }
-
- if (free_recvbufs > 0)
+ if (free_recvbufs <= 0)
{
- buffer = freelist;
- freelist = buffer->next;
- buffer->next = NULL;
- --free_recvbufs;
+ create_buffers(RECV_INC);
+ }
+ buffer = ISC_LIST_HEAD(free_list);
+ if (buffer == NULL)
+ {
+ msyslog(LOG_ERR, "free recvbufs was incorrect (%ld)",
+ free_recvbufs);
+ }
+ else
+ {
+ ISC_LIST_DEQUEUE(free_list, buffer, link);
}
-
UNLOCK();
- return buffer;
+ return (buffer);
}
-struct recvbuf *
+recvbuf_t *
get_full_recv_buffer(void)
{
- struct recvbuf * buffer = NULL;
+ recvbuf_t *rbuf;
LOCK();
- if (full_recvbufs > 0) {
+ rbuf = ISC_LIST_HEAD(full_list);
+ if (rbuf != NULL)
+ {
+ ISC_LIST_DEQUEUE(full_list, rbuf, link);
--full_recvbufs;
- buffer = beginlist;
- beginlist = buffer->next;
- buffer->next = NULL;
}
UNLOCK();
- return buffer;
+ return (rbuf);
}
)
{
l_fp now;
- struct recvbuf *rbuflist;
+ int tot_full_recvbufs;
struct recvbuf *rbuf;
#ifdef _AIX /* HMS: ifdef SIGDANGER? */
struct sigaction sa;
}
#endif
-#ifdef OPENSSL
- if ((SSLeay() ^ OPENSSL_VERSION_NUMBER) & ~0xff0L) {
- msyslog(LOG_ERR,
- "ntpd: OpenSSL version mismatch. Built against %lx, you have %lx\n",
- OPENSSL_VERSION_NUMBER, SSLeay());
- exit(1);
- }
-#endif
-
#ifdef SYS_WINNT
/*
* Initialize the time structures and variables
"Cannot adjust stack limit for mlockall: %m");
}
}
-# ifdef RLIMIT_MEMLOCK
- /*
- * The default RLIMIT_MEMLOCK is very low on Linux systems.
- * Unless we increase this limit malloc calls are likely to
- * fail if we drop root privlege. To be useful the value
- * has to be larger than the largest ntpd resident set size.
- */
- rl.rlim_cur = rl.rlim_max = 32*1024*1024;
- if (setrlimit(RLIMIT_MEMLOCK, &rl) == -1) {
- msyslog(LOG_ERR, "Cannot set RLIMIT_MEMLOCK: %m");
- }
-# endif /* RLIMIT_MEMLOCK */
}
# endif /* HAVE_SETRLIMIT */
/*
#if defined(HAVE_IO_COMPLETION_PORT)
for (;;) {
- rbuflist = GetReceivedBuffers();
+ tot_full_recvbufs = GetReceivedBuffers();
#else /* normal I/O */
was_alarmed = 0;
- rbuflist = (struct recvbuf *)0;
for (;;)
{
# if !defined(HAVE_SIGNALED_IO)
block_io_and_alarm();
# endif
- rbuflist = getrecvbufs(); /* get received buffers */
+ tot_full_recvbufs = full_recvbuffs(); /* get received buffers */
if (alarm_flag) /* alarmed? */
{
was_alarmed = 1;
alarm_flag = 0;
}
- if (!was_alarmed && rbuflist == (struct recvbuf *)0)
+ if (!was_alarmed && tot_full_recvbufs > 0)
{
/*
* Nothing to do. Wait for something.
was_alarmed = 1;
alarm_flag = 0;
}
- rbuflist = getrecvbufs(); /* get received buffers */
+ tot_full_recvbufs = full_recvbuffs(); /* get received buffers */
}
# ifdef HAVE_SIGNALED_IO
unblock_io_and_alarm();
* Call the data procedure to handle each received
* packet.
*/
- while (rbuflist != (struct recvbuf *)0)
+ rbuf = get_full_recv_buffer();
+ while (rbuf != NULL)
{
- rbuf = rbuflist;
- rbuflist = rbuf->next;
(rbuf->receiver)(rbuf);
freerecvbuf(rbuf);
+ rbuf = get_full_recv_buffer();
}
-#if defined DEBUG && defined SYS_WINNT
- if (debug > 4)
- printf("getrecvbufs: %ld handler interrupts, %ld frames\n",
- handler_calls, handler_pkts);
-#endif
/*
* Go around again
buf.srcadr = rbufp->srcadr;
buf.dstadr = rbufp->dstadr;
buf.fd = rbufp->fd;
- buf.next = 0;
buf.X_from_where = rbufp->X_from_where;
rbufp->receiver(&buf);
}
)
{
int was_alarmed;
- struct recvbuf *rbuflist;
+ int tot_recvbufs;
struct recvbuf *rbuf;
l_fp tmp;
int errflg;
initializing = 0;
was_alarmed = 0;
- rbuflist = (struct recvbuf *)0;
while (complete_servers < sys_numservers) {
#ifdef HAVE_POLL_H
was_alarmed = 1;
alarm_flag = 0;
}
- rbuflist = getrecvbufs(); /* get received buffers */
+ tot_recvbufs = full_recvbuffs(); /* get received buffers */
- if (!was_alarmed && rbuflist == (struct recvbuf *)0) {
+ if (!was_alarmed && tot_recvbufs > 0) {
/*
* Nothing to do. Wait for something.
*/
was_alarmed = 1;
alarm_flag = 0;
}
- rbuflist = getrecvbufs(); /* get received buffers */
+ tot_recvbufs = full_recvbuffs(); /* get received buffers */
}
/*
* Out here, signals are unblocked. Call receive
* procedure for each incoming packet.
*/
- while (rbuflist != (struct recvbuf *)0) {
- rbuf = rbuflist;
- rbuflist = rbuf->next;
+ rbuf = get_full_recv_buffer();
+ while (rbuf != NULL)
+ {
receive(rbuf);
freerecvbuf(rbuf);
+ rbuf = get_full_recv_buffer();
}
/*
)
{
int was_alarmed;
- struct recvbuf *rbuflist;
+ int tot_recvbufs;
struct recvbuf *rbuf;
l_fp tmp;
int errflg;
* yet to learn about anything else that is.
*/
was_alarmed = 0;
- rbuflist = (struct recvbuf *)0;
while (finish_time > current_time) {
#if !defined(HAVE_SIGNALED_IO)
fd_set rdfdes;
block_io_and_alarm();
#endif
- rbuflist = getrecvbufs(); /* get received buffers */
+ tot_recvbufs = full_recvbuffs(); /* get received buffers */
if (printmsg) {
printmsg = 0;
analysis(0);
alarm_flag = 0;
}
- if (!was_alarmed && rbuflist == (struct recvbuf *)0) {
+ if (!was_alarmed && tot_recvbufs > 0) {
/*
* Nothing to do. Wait for something.
*/
was_alarmed = 1;
alarm_flag = 0;
}
- rbuflist = getrecvbufs(); /* get received buffers */
+ tot_recvbufs = full_recvbuffs(); /* get received buffers */
}
#ifdef HAVE_SIGNALED_IO
unblock_io_and_alarm();
* Call the data procedure to handle each received
* packet.
*/
- while (rbuflist != (struct recvbuf *)0)
+ rbuf = get_full_recv_buffer();
+ while (rbuf != NULL)
{
- rbuf = rbuflist;
- rbuflist = rbuf->next;
receive(rbuf);
freerecvbuf(rbuf);
+ rbuf = get_full_recv_buffer();
}
-#if defined DEBUG && defined SYS_WINNT
- if (debug > 4)
- printf("getrecvbufs: %ld handler interrupts, %ld frames\n",
- handler_calls, handler_pkts);
-#endif
/*
* Do we have enough information to stop now?
#if defined HAVE_IO_COMPLETION_PORT
# include "ntp_iocompletionport.h"
#endif
+#include <isc/list.h>
/*
* Format of a transmitbuf. These are used by the asynchronous receive
- * routine to store incoming packets and related information.
+ * routine to store outgoing packets and related information.
*/
+typedef struct transmitbuf transmitbuf_t;
+
typedef struct transmitbuf {
- struct transmitbuf *next; /* next buffer in chain */
+ ISC_LINK(transmitbuf_t) link;
WSABUF wsabuf;
time_t ts; /* Time stamp for the request */
/* freetransmitbuf - make a single transmitbuf available for reuse
*/
-extern void free_transmit_buffer P((transmitbuf *));
+extern void free_transmit_buffer P((transmitbuf_t *));
/* Get a free buffer (typically used so an async
* read can directly place data into the buffer
* The buffer is removed from the free list. Make sure
* you put it back with freetransmitbuf() or
*/
-extern transmitbuf *get_free_transmit_buffer P((void));
+extern transmitbuf_t *get_free_transmit_buffer P((void));
#endif /* defined __transmitbuff_h */
/*
* transmitbuf memory management
*/
-#define TRANSMIT_INIT 10 /* 10 buffers initially */
-#define TRANSMIT_LOWAT 3 /* when we're down to three buffers get more */
-#define TRANSMIT_INC 5 /* get 5 more at a time */
+#define TRANSMIT_INIT 10 /* 10 buffers initially */
+#define TRANSMIT_LOWAT 3 /* when we're down to three buffers get more */
+#define TRANSMIT_INC 5 /* get 5 more at a time */
#define TRANSMIT_TOOMANY 40 /* this is way too many buffers */
-/*
- * Maximum time in seconds to allow transmit request to complete
- * After that we are free to delete it if we need the buffer
- */
-
-#define MAX_TRANSMIT_SEND_TIME 60.0
-
/*
* Memory allocation
*/
-static volatile u_long full_transmitbufs = 0; /* number of transmitbufs on fulllist */
-static volatile u_long free_transmitbufs = 0; /* number of transmitbufs on freelist */
-
-typedef struct transmitb transmitb_t;
+static volatile u_long full_transmitbufs = 0; /* number of transmitbufs on fulllist */
+static volatile u_long free_transmitbufs = 0; /* number of transmitbufs on freelist */
-struct transmitb {
- transmitbuf *tb;
- ISC_LINK(transmitb_t) link;
-};
-
-ISC_LIST(transmitb_t) fulllist; /* Currently used transmit buffers */
-
-static transmitbuf *volatile freelist = NULL; /* free buffers */
-static transmitbuf *volatile beginlist = NULL; /* fifo buffers with data */
+ISC_LIST(transmitbuf_t) free_list; /* Currently used transmit buffers */
+ISC_LIST(transmitbuf_t) full_list; /* Currently used transmit buffers */
static u_long total_transmitbufs = 0; /* total transmitbufs currently in use */
-static u_long lowater_additions = 0; /* number of times we have added memory */
-
-static transmitbuf initial_bufs[TRANSMIT_INIT]; /* initial allocation */
-
+static u_long lowater_additions = 0; /* number of times we have added memory */
static CRITICAL_SECTION TransmitLock;
# define LOCK(lock) EnterCriticalSection(lock)
# define UNLOCK(lock) LeaveCriticalSection(lock)
-static struct transmitbuf initial_bufs[TRANSMIT_INIT]; /* initial allocation */
-static int eventid = 0;
-
static void
initialise_buffer(transmitbuf *buff)
{
buff->wsabuf.buf = (char *) &buff->pkt;
}
+static void
+add_buffer_to_freelist(transmitbuf *tb)
+{
+ ISC_LIST_APPEND(free_list, tb, link);
+ free_transmitbufs++;
+}
+
+static void
+create_buffers(int nbufs)
+{
+ transmitbuf_t *buf;
+ int i;
+
+ buf = (transmitbuf_t *) emalloc(nbufs*sizeof(transmitbuf_t));
+ for (i = 0; i < nbufs; i++)
+ {
+ initialise_buffer(buf);
+ add_buffer_to_freelist(buf);
+ total_transmitbufs++;
+ buf++;
+ }
+
+ lowater_additions++;
+}
extern void
init_transmitbuff(void)
{
- int i;
/*
* Init buffer free list and stat counters
*/
- freelist = NULL;
- for (i = 0; i < TRANSMIT_INIT; i++)
- {
- initialise_buffer(&initial_bufs[i]);
- initial_bufs[i].next = (transmitbuf *) freelist;
- freelist = &initial_bufs[i];
- }
-
- ISC_LIST_INIT(fulllist);
- free_transmitbufs = total_transmitbufs = TRANSMIT_INIT;
+ ISC_LIST_INIT(full_list);
+ ISC_LIST_INIT(free_list);
+ free_transmitbufs = total_transmitbufs = 0;
full_transmitbufs = lowater_additions = 0;
+ create_buffers(TRANSMIT_INIT);
InitializeCriticalSection(&TransmitLock);
}
static void
-add_buffer_to_freelist(transmitbuf *tb)
-{
- tb->next = freelist;
- freelist = tb;
- free_transmitbufs++;
-}
-
-static void
-delete_buffer_from_full_list(transmitbuf *tb) {
+delete_buffer_from_full_list(transmitbuf_t *tb) {
- transmitb_t *next;
- transmitb_t *lbuf = ISC_LIST_HEAD(fulllist);
+ transmitbuf_t *next = NULL;
+ transmitbuf_t *lbuf = ISC_LIST_HEAD(full_list);
- while(lbuf != NULL) {
+ while (lbuf != NULL) {
next = ISC_LIST_NEXT(lbuf, link);
- if(lbuf->tb == tb) {
- ISC_LIST_DEQUEUE_TYPE(fulllist, lbuf, link, transmitb_t);
- free(lbuf);
+ if (lbuf == tb) {
+ ISC_LIST_DEQUEUE(full_list, lbuf, link);
break;
}
else
lbuf = next;
}
+ full_transmitbufs--;
}
-/*
- * routine to free up any buffer that has not been freed up
- * after MAX_TRANSMIT_SEND_TIME seconds. Note that we are not being
- * too careful here about the correct value of time since we just need
- * and approximate measure of how much time has elapsed since the
- * packet was sent and this routine is only called if we run out
- * of tranmit buffers.
- */
-static int
-free_unsent_buffers()
-{
- int tot_freed = 0;
- double elapsed_time;
- time_t ct;
- transmitbuf *buf;
- transmitb_t *next;
- transmitb_t *lbuf = ISC_LIST_HEAD(fulllist);
-
- time(&ct); /* Current Time */
-
- LOCK(&TransmitLock);
- while(lbuf != NULL) {
- next = ISC_LIST_NEXT(lbuf, link);
- elapsed_time = difftime(ct, lbuf->tb->ts);
- if (elapsed_time > MAX_TRANSMIT_SEND_TIME) {
- ISC_LIST_DEQUEUE_TYPE(fulllist, lbuf, link, transmitb_t);
- free(lbuf);
- add_buffer_to_freelist(lbuf->tb);
- tot_freed++;
- }
- else
- lbuf = next;
- }
- UNLOCK(&TransmitLock);
- return (tot_freed);
-}
-
-static void
-create_buffers(void)
-{
- transmitbuf *buf;
- int i;
- if (free_unsent_buffers() > 0)
- return;
-
- buf = (transmitbuf *) emalloc(TRANSMIT_INC*sizeof(transmitbuf));
- for (i = 0; i < TRANSMIT_INC; i++)
- {
- initialise_buffer(buf);
- buf->next = (transmitbuf *) freelist;
- freelist = buf;
- buf++;
- }
-
- free_transmitbufs += TRANSMIT_INC;
- total_transmitbufs += TRANSMIT_INC;
- lowater_additions++;
-}
-
-
extern void
-free_transmit_buffer(transmitbuf *rb)
+free_transmit_buffer(transmitbuf_t *rb)
{
LOCK(&TransmitLock);
- add_buffer_to_freelist(rb);
delete_buffer_from_full_list(rb);
+ add_buffer_to_freelist(rb);
UNLOCK(&TransmitLock);
}
extern transmitbuf *
get_free_transmit_buffer(void)
{
- transmitb_t *lbuf = (transmitb_t *)malloc(sizeof(transmitb_t));
- transmitbuf * buffer = NULL;
+ transmitbuf_t * buffer = NULL;
LOCK(&TransmitLock);
if (free_transmitbufs <= 0) {
- create_buffers();
+ create_buffers(TRANSMIT_INC);
+ }
+ buffer = ISC_LIST_HEAD(free_list);
+ if (buffer != NULL)
+ {
+ ISC_LIST_DEQUEUE(free_list, buffer, link);
+ free_transmitbufs--;
+ ISC_LIST_APPEND(full_list, buffer, link);
+ full_transmitbufs++;
}
- buffer = freelist;
- freelist = buffer->next;
- buffer->next = NULL;
- time(&buffer->ts); /* Time we gave out the transmit buffer */
- lbuf->tb = buffer;
- ISC_LIST_APPEND(fulllist, lbuf, link);
- --free_transmitbufs;
UNLOCK(&TransmitLock);
- return buffer;
+ return (buffer);
}
#endif
break;
}
+ /* Clear the allocated memory */
+ if (lpo != NULL)
+ {
+ HeapFree(hHeapHandle, 0, lpo);
+ lpo = NULL;
+ }
}
}
* Create a handle to the Heap
*/
hHeapHandle = HeapCreate(0, 20*sizeof(IoCompletionInfo), 0);
+ if (hHeapHandle == NULL)
+ {
+ msyslog(LOG_ERR, "Can't initialize Heap: %m");
+ exit(1);
+ }
+
/* Create the event used to signal an IO event
*/
lpo = (IoCompletionInfo *) HeapAlloc(hHeapHandle,
HEAP_ZERO_MEMORY,
sizeof(IoCompletionInfo));
+ if (lpo == NULL)
+ return 0;
+
buff = get_free_recv_buffer();
-
+
if (buff == NULL)
+ {
+ HeapFree(hHeapHandle, 0, lpo);
return 0;
+ }
lpo->request_type = CLOCK_READ;
lpo->buff = buff;
else
freerecvbuf(buff);
- /* Clear the heap */
- if (lpo != NULL)
- HeapFree(hHeapHandle, 0, lpo);
-
QueueIORead( rio );
return 1;
}
lpo = (IoCompletionInfo *) HeapAlloc(hHeapHandle,
HEAP_ZERO_MEMORY,
sizeof(IoCompletionInfo));
+ if (lpo == NULL)
+ return 0;
+
buff = get_free_recv_buffer();
+ if (buff == NULL)
+ {
+ HeapFree(hHeapHandle, 0, lpo);
+ return 0;
+ }
+
lpo->request_type = SOCK_RECV;
lpo->buff = buff;
case WSA_IO_INCOMPLETE :
case WSA_WAIT_IO_COMPLETION :
case WSA_IO_PENDING :
- break ;
+ break ;
case WSAENOTSOCK :
netsyslog(LOG_ERR, "Can't read from socket, because it isn't a socket: %m");
else {
freerecvbuf(buff);
}
- /* Clear the heap */
- if (lpo != NULL)
- HeapFree(hHeapHandle, 0, lpo);
QueueSocketRecv(inter->fd);
return 1;
static int
OnWriteComplete(DWORD Key, IoCompletionInfo *lpo, DWORD Bytes)
{
- transmitbuf *buff = NULL;
+ transmitbuf_t *buff;
(void) Bytes;
(void) Key;
- buff = (struct transmitbuf *) lpo->buff;
+ buff = (transmitbuf_t *) lpo->buff;
free_transmit_buffer(buff);
- /* Clear the heap */
- if (lpo != NULL)
- HeapFree(hHeapHandle, 0, lpo);
return 1;
}
int len,
struct sockaddr_storage* dest)
{
- transmitbuf *buff = NULL;
+ transmitbuf_t *buff = NULL;
DWORD Result = ERROR_SUCCESS;
int errval;
int AddrLen;
HEAP_ZERO_MEMORY,
sizeof(IoCompletionInfo));
+ if (lpo == NULL)
+ return ERROR_OUTOFMEMORY;
+
if (len <= sizeof(buff->pkt)) {
buff = get_free_transmit_buffer();
if (buff != NULL) {
if (debug)
printf("No more transmit buffers left - data discarded\n");
#endif
+ HeapFree(hHeapHandle, 0, lpo);
return ERROR_OUTOFMEMORY;
}
}
else {
#ifdef DEBUG
- if (debug) printf("Packet too large\n");
+ if (debug) printf("Packet too large: %d Bytes\n", len);
#endif
return ERROR_INSUFFICIENT_BUFFER;
}
int len)
{
DWORD errval;
- transmitbuf *buff = NULL;
+ transmitbuf_t *buff = NULL;
DWORD lpNumberOfBytesWritten;
DWORD Result = ERROR_INSUFFICIENT_BUFFER;
IoCompletionInfo *lpo;
HEAP_ZERO_MEMORY,
sizeof(IoCompletionInfo));
+ if (lpo == NULL)
+ return ERROR_OUTOFMEMORY;
+
if (len <= sizeof(buff->pkt)) {
buff = get_free_transmit_buffer();
if (buff != NULL) {
if (debug)
printf("No more transmit buffers left - data discarded\n");
#endif
-
+ HeapFree(hHeapHandle, 0, lpo);
}
}
else {
#ifdef DEBUG
- if (debug) printf("Packet too large\n");
+ if (debug) printf("Packet too large: %d Bytes\n", len);
#endif
}
return Result;
* Note that this is in effect the main loop for processing requests
* both send and receive. This should be reimplemented
*/
-struct recvbuf *GetReceivedBuffers()
+int GetReceivedBuffers()
{
DWORD Index = WaitForMultipleObjectsEx(MAXHANDLES, WaitHandles, FALSE, INFINITE, TRUE);
switch (Index) {
} /* switch */
- return (getrecvbufs()); /* get received buffers */
+ return (full_recvbuffs()); /* get received buffers */
}
#else
projects / thirdparty / ntp.git / commitdiff
