(npcb->mss & 255));
    /* Send a SYN|ACK together with the MSS option. */
    tcp_enqueue(npcb, NULL, 0, TCP_SYN | TCP_ACK, 0, (u8_t *)&optdata, 4);
    return tcp_output(npcb);
  }

#define RTP_SEQ_IS_GREATER(seq1,seq2)\
     ((uint16_t)((uint16_t)(seq1) - (uint16_t)(seq2))< (uint16_t)(1<<15))
/* put an rtp packet in queue. It is called by rtp_parse()*/
void rtp_putq(queue_t *q, mblk_t *mp)
{

     rtcp_common_header_t *rtcp;
    mblk_t *tmp,*m=mp;
     queue_t *q;
     int rc=0;
    rtcp = (rtcp_common_header_t*)mp->b_wptr;

{
  /* no data, no length, flags, copy=1, no optdata, no optdatalen */
  return tcp_enqueue(pcb, NULL, 0, flags, 1, NULL, 0);
}
/**

#include "utils.h"
#include "rtpsession_priv.h"
void split_and_queue(queue_t *q, int maxrqsz, mblk_t *mp, rtp_header_t *rtp, int *discarded)
{
     mblk_t *mdata,*tmp;

 * list. This is called a "pbuf chain".
 *
 * Multiple packets may be queued, also using this singly linked list.
 * This is called a "packet queue".
 *

   connections. */
#define MEMP_NUM_TCP_PCB_LISTEN 8
/* MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP
   segments. */
#define MEMP_NUM_TCP_SEG        16

      tcp_segs_free(pcb->unsent);
    }
#if TCP_QUEUE_OOSEQ    
    if (pcb->ooseq != NULL) {
      tcp_segs_free(pcb->ooseq);

Print the current time, the length of time the system has been up,\n\
the number of users on the system, and the average number of jobs\n\
in the run queue over the last 1, 5 and 15 minutes.\n\
If FILE is not specified, use %s.  %s as FILE is common.\n\
\n\

  u16_t acked;
  u16_t snd_buf;   /* Available buffer space for sending (in bytes). */
#define TCP_SNDQUEUELEN_OVERFLOW (0xffff-3)
  u16_t snd_queuelen; /* Available buffer space for sending (in tcp_segs). */
  /* These are ordered by sequence number: */

                      enum filetype type);
static void print_with_commas (void);
static void queue_directory (char const *name, char const *realname,
                    bool command_line_arg);
static void sort_files (void);

 *         an err_t value if the packet couldn't be sent
 *
 * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
 *       strange results. You might consider waiting for space in the DMA queue
 *       to become availale since the stack doesn't retry to send a packet

extern Lisp_Object Vw32_scroll_lock_modifier;
extern unsigned int w32_key_to_modifier (int key);
/* Event queue */
#define EVENT_QUEUE_SIZE 50
static INPUT_RECORD event_queue[EVENT_QUEUE_SIZE];

};
struct etharp_entry {
#if ARP_QUEUEING
  /** 
   * Pointer to queue of pending outgoing packets on this ARP entry.

         * want to give user interface processing precedence over the
         * network.  To achieve this, the socket IO messages are used to
         * set status indicators.  When the GUI is idle (message queue is
         * empty), we go back and check those indicators.  It is at this
      * point that the actual network IO occurs.

    NPMODE_DROP,        /* silently drop the packet */
    NPMODE_ERROR,       /* return an error */
    NPMODE_QUEUE        /* save it up for later. */
};
/*

#ifdef OSIP_MT
  ff->qislocked = osip_mutex_init ();
  /*INIT SEMA TO BLOCK ON GET() WHEN QUEUE IS EMPTY */
  ff->qisempty = osip_sem_init (0);
#endif

#include "ortp/str_utils.h"
#include "utils.h"
void qinit(queue_t *q){
     mblk_init(&q->_q_stopper);
     q->_q_stopper.b_next=&q->_q_stopper;

    /* This loops until the accept() fails, trying to start new
    ** connections as fast as possible so we don't overrun the
    ** listen queue.
    */
    for (;;)

#endif
/**
 * MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments.
 * (requires the LWIP_TCP option)
 */

   * belonging to the same packet.
   *
   * For non-queue packet chains this is the invariant:
   * p->tot_len == p->len + (p->next? p->next->tot_len: 0)
   */

}
void
gv_view_area_queue_draw(GvViewArea *view)
{
    gv_manager_set_busy( gv_get_manager(), TRUE );

          nh++;
           }
         /* Check for any emacs-generated input in the queue since
            it won't be detected in the wait */
         if (detect_input_pending ())

 *
 * Revision 1.58  2001/01/30 15:18:01  warmerda
 * added queue_task() access from python
 *
 * Revision 1.57  2000/10/06 16:48:56  warmerda

     }
      /* The new line just read in may be larger than other lines
      already in main memory; push it back in the queue until we
      encounter a line larger than it.  Optimize for the common
      case where the new line is smallest.  */