void readPkt(char * a){
uint8_t i;
for(i=0;i<sizeof(struct pkt);i++){
sblock(); // wait until next character received
a[i] = Serial.read();
}
}
TEST(BlockTest, FindEdgeRecursive)
{
// To recurse, need two entries in block map, no instructions in
// the block that have a name, a branch instruction to the second
// block and a named instruction in the second block. When
// calling findEdge with the first block, the id of the
// instruction with a name in the second block should be returned.
llvm::LLVMContext context;
llvm::BasicBlock* fbblock = llvm::BasicBlock::Create(context);
llvm::BasicBlock* sbblock = llvm::BasicBlock::Create(context);
llvm::BranchInst* finstruction = llvm::BranchInst::Create(sbblock);
llvm::BranchInst* sinstruction = llvm::BranchInst::Create(fbblock);
pBlock fblock(new Block(0));
pBlock sblock(new Block(1));
pNode fnode(new Node(0));
pNode snode(new Node(1));
fbblock->getInstList().push_back(finstruction);
sbblock->getInstList().push_back(sinstruction);
fblock->appendNode(fnode);
sblock->appendNode(snode);
fnode->setInstruction(finstruction);
snode->setInstruction(sinstruction);
snode->setNodeLabel("test_label");
std::map<llvm::BasicBlock*, pBlock> blocks;
blocks.insert(std::pair<llvm::BasicBlock*, pBlock>(fbblock, fblock));
blocks.insert(std::pair<llvm::BasicBlock*, pBlock>(sbblock, sblock));
ASSERT_EQ(1, fblock->findEdge(fbblock, blocks));
}
bool ompl_interface::OMPLInterface::solve(const planning_scene::PlanningSceneConstPtr& planning_scene,
const planning_interface::MotionPlanRequest &req, planning_interface::MotionPlanDetailedResponse &res) const
{
moveit::tools::Profiler::ScopedStart pslv;
moveit::tools::Profiler::ScopedBlock sblock("OMPLInterface:Solve");
ModelBasedPlanningContextPtr context = getPlanningContext(planning_scene, req);
if (context)
{
context->clear();
return context->solve(res);
}
else
return false;
}
/* FUNCTION: sorflush()
*
* PARAM1: struct socket * socket structure
*
* RETURNS: none
*
* Closes the "read" half of the socket connection. No more data
* can be received on the socket, and any data currently in the
* socket receive buffer is discarded. Wakeup any processes waiting
* on the socket.
*/
void
sorflush(struct socket * so)
{
struct sockbuf *sb = &so->so_rcv;
int s;
sblock(sb);
socantrcvmore(so);
sbunlock(sb);
sbrelease(sb);
MEMSET((char *)sb, 0, sizeof (*sb));
s = so->so_error;
so->so_error = ESHUTDOWN;
sorwakeup(so);
so->so_error = s;
}
int
soreceive(struct socket * so,
struct mbuf **aname,
char * data,
int * datalen,
int flags)
{
struct mbuf * m;
int len;
int error = 0;
int offset;
struct protosw * pr = so->so_proto;
struct mbuf * nextrecord;
int moff;
int lflags;
if (aname)
*aname = 0;
if (flags & MSG_OOB)
{
m = m_get (M_WAIT, MT_RXDATA);
if (m == NULL)
return ENOBUFS;
lflags = flags & MSG_PEEK;
so->so_req = PRU_RCVOOB;
error = (*pr->pr_usrreq)(so, m, LONG2MBUF((long)lflags));
if (error == 0)
{
do
{
len = *datalen;
if (len > (int)m->m_len)
len = m->m_len;
MEMCPY(data, mtod(m, char*), len);
data += len;
*datalen = len;
m = m_free(m);
} while (*datalen && (error == 0) && m);
}
if (m)
m_freem(m);
return (error);
}
restart:
sblock (&so->so_rcv);
INET_TRACE (INETM_IO,
("INET:soreceive sbcc %d soerror %d so_state %d *datalen %d\n",
so->so_rcv.sb_cc, so->so_error, so->so_state, *datalen));
/* If no data is ready, see if we should wait or return */
if (so->so_rcv.sb_cc == 0)
{
if (so->so_error)
{
error = so->so_error;
so->so_error = 0;
goto release;
}
if (so->so_state & SS_CANTRCVMORE)
goto release;
if ((so->so_state & SS_ISCONNECTED) == 0 &&
(so->so_proto->pr_flags & PR_CONNREQUIRED))
{
error = ENOTCONN;
goto release;
}
if (*datalen == 0)
goto release;
if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT))
{
error = EWOULDBLOCK;
goto release;
}
sbunlock(&so->so_rcv);
sbwait(&so->so_rcv);
goto restart;
}
m = so->so_rcv.sb_mb;
if (m == 0)
panic("sorecv 1");
nextrecord = m->m_act;
if (pr->pr_flags & PR_ADDR)
{
if (m->m_type != MT_SONAME)
{
dprintf ("sorecv:type %d not nam", m->m_type);
panic("sorecv 2");
}
if (flags & MSG_PEEK)
{
if (aname)
*aname = m_copy (m, 0, m->m_len);
m = m->m_next;
} else
{
sbfree (&so->so_rcv, m);
if (aname)
{
*aname = m;
m = m->m_next;
(*aname)->m_next = 0;
so->so_rcv.sb_mb = m;
} else
{
MFREE(m, so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}
if (m)
m->m_act = nextrecord;
}
}
moff = 0;
offset = 0;
while (m && (*datalen > 0) && (error == 0))
{
if (m->m_type != MT_RXDATA && m->m_type != MT_HEADER)
panic("sorecv 3");
len = *datalen;
so->so_state &= ~SS_RCVATMARK;
if (so->so_oobmark && (len > (int)(so->so_oobmark - offset)))
len = (int)(so->so_oobmark - offset);
if (len > (int)(m->m_len - moff))
len = m->m_len - moff;
INET_TRACE (INETM_IO, ("INET: soreceive, so %lx %d bytes, flags %x\n",
so, len, flags));
/*
* Copy mbufs info user buffer, then free them.
* Sockbuf must be consistent here (points to current mbuf,
* it points to next record) when we drop priority;
* we must note any additions to the sockbuf when we
* block interrupts again.
*/
MEMCPY(data, (mtod(m, char *) + moff), len);
data += len;
*datalen -= len;
if (len == (int)(m->m_len - moff))
{
if (flags & MSG_PEEK)
{
m = m->m_next;
moff = 0;
} else
{
nextrecord = m->m_act;
sbfree(&so->so_rcv, m);
{
MFREE(m, so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}
if (m)
m->m_act = nextrecord;
}
} else
{
if (flags & MSG_PEEK)
moff += len;
else
{
m->m_data += len;
m->m_len -= len;
so->so_rcv.sb_cc -= len;
}
}
if (so->so_oobmark)
{
if ((flags & MSG_PEEK) == 0)
{
so->so_oobmark -= len;
if (so->so_oobmark == 0)
{
so->so_state |= SS_RCVATMARK;
break;
}
} else
offset += len;
}
}
if ((flags & MSG_PEEK) == 0)
{
if (m == 0)
so->so_rcv.sb_mb = nextrecord;
else if (pr->pr_flags & PR_ATOMIC)
(void) sbdroprecord(&so->so_rcv);
if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
{
so->so_req = PRU_RCVD;
(*pr->pr_usrreq)(so, (struct mbuf *)0,
(struct mbuf *)0);
}
}
release:
sbunlock(&so->so_rcv);
return (error);
}
int
sosend(struct socket *so,
struct mbuf *nam, /* sockaddr, if UDP socket, NULL if TCP */
char *data, /* data to send */
int *data_length, /* IN/OUT length of (remaining) data */
int flags)
{
struct mbuf *head = (struct mbuf *)NULL;
struct mbuf *m;
int space;
int resid;
int len;
int error = 0;
int dontroute;
int first = 1;
resid = *data_length;
/*
* In theory resid should be unsigned.
* However, space must be signed, as it might be less than 0
* if we over-committed, and we must use a signed comparison
* of space and resid. On the other hand, a negative resid
* causes us to loop sending 0-length segments to the protocol.
*/
if (resid < 0)
return (EINVAL);
INET_TRACE (INETM_IO, ("INET:sosend: so %lx resid %d sb_hiwat %d so_state %x\n",
so, resid, so->so_snd.sb_hiwat, so->so_state));
if (sosendallatonce(so) && (resid > (int)so->so_snd.sb_hiwat))
return (EMSGSIZE);
dontroute = (flags & MSG_DONTROUTE) &&
((so->so_options & SO_DONTROUTE) == 0) &&
(so->so_proto->pr_flags & PR_ATOMIC);
#define snderr(errno) { error = errno; goto release; }
restart:
sblock(&so->so_snd);
do
{
if (so->so_error)
{
error = so->so_error;
so->so_error = 0; /* ??? */
goto release;
}
if (so->so_state & SS_CANTSENDMORE)
snderr(EPIPE);
if ((so->so_state & SS_ISCONNECTED) == 0)
{
if (so->so_proto->pr_flags & PR_CONNREQUIRED)
snderr(ENOTCONN);
if (nam == 0)
snderr(EDESTADDRREQ);
}
if (flags & MSG_OOB)
space = 1024;
else
{
space = (int)sbspace(&so->so_snd);
if ((sosendallatonce(so) && (space < resid)) ||
((resid >= CLBYTES) && (space < CLBYTES) &&
(so->so_snd.sb_cc >= CLBYTES) &&
((so->so_state & SS_NBIO) == 0) &&
((flags & MSG_DONTWAIT) == 0)))
{
if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT))
{
if (first)
error = EWOULDBLOCK;
goto release;
}
sbunlock(&so->so_snd);
sbwait(&so->so_snd);
goto restart;
}
}
if ( space <= 0 )
{
/* no space in socket send buffer - see if we can wait */
if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT))
{
if (first) /* report first error */
error = EWOULDBLOCK;
goto release;
}
/* If blocking socket, let someone else run */
sbunlock(&so->so_snd);
sbwait(&so->so_snd);
goto restart;
}
while (space > 0)
{
len = resid;
if ( so->so_type == SOCK_STREAM )
{
m = m_getwithdata(MT_TXDATA, len);
if (!m)
snderr(ENOBUFS);
MEMCPY(m->m_data, data, len);
so->so_snd.sb_flags |= SB_MBCOMP; /* allow compression */
}
else
{
m = m_get (M_WAIT, MT_TXDATA);
m->m_data = data;
}
INET_TRACE (INETM_IO,
("sosend:got %d bytes so %lx mlen %d, off %d mtod %x\n",
len, so, m->m_len, m->m_off, mtod (m, caddr_t)));
*data_length -= len;
resid -= len;
data += len;
m->m_len = len;
if (head == (struct mbuf *)NULL)
head = m;
if (error)
goto release;
if (*data_length <= 0)
break;
}
if (dontroute)
so->so_options |= SO_DONTROUTE;
so->so_req = (flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND;
error = (*so->so_proto->pr_usrreq)(so, head, nam);
if (dontroute)
so->so_options &= ~SO_DONTROUTE;
head = (struct mbuf *)NULL;
first = 0;
} while ((resid != 0) && (error == 0));
release:
sbunlock(&so->so_snd);
if (head)
m_freem(head);
return error;
}
static int
kttcp_soreceive(struct socket *so, unsigned long long slen,
unsigned long long *done, struct lwp *l, int *flagsp)
{
struct mbuf *m, **mp;
int flags, len, error, offset, moff, type;
long long orig_resid, resid;
const struct protosw *pr;
struct mbuf *nextrecord;
pr = so->so_proto;
mp = NULL;
type = 0;
resid = orig_resid = slen;
if (flagsp)
flags = *flagsp &~ MSG_EOR;
else
flags = 0;
if (flags & MSG_OOB) {
m = m_get(M_WAIT, MT_DATA);
solock(so);
error = (*pr->pr_usrreqs->pr_recvoob)(so, m, flags & MSG_PEEK);
sounlock(so);
if (error)
goto bad;
do {
resid -= min(resid, m->m_len);
m = m_free(m);
} while (resid && error == 0 && m);
bad:
if (m)
m_freem(m);
return (error);
}
if (mp)
*mp = NULL;
solock(so);
restart:
if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0)
return (error);
m = so->so_rcv.sb_mb;
/*
* If we have less data than requested, block awaiting more
* (subject to any timeout) if:
* 1. the current count is less than the low water mark,
* 2. MSG_WAITALL is set, and it is possible to do the entire
* receive operation at once if we block (resid <= hiwat), or
* 3. MSG_DONTWAIT is not set.
* If MSG_WAITALL is set but resid is larger than the receive buffer,
* we have to do the receive in sections, and thus risk returning
* a short count if a timeout or signal occurs after we start.
*/
if (m == NULL || (((flags & MSG_DONTWAIT) == 0 &&
so->so_rcv.sb_cc < resid) &&
(so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
((flags & MSG_WAITALL) && resid <= so->so_rcv.sb_hiwat)) &&
m->m_nextpkt == NULL && (pr->pr_flags & PR_ATOMIC) == 0)) {
#ifdef DIAGNOSTIC
if (m == NULL && so->so_rcv.sb_cc)
panic("receive 1");
#endif
if (so->so_error) {
if (m)
goto dontblock;
error = so->so_error;
if ((flags & MSG_PEEK) == 0)
so->so_error = 0;
goto release;
}
if (so->so_state & SS_CANTRCVMORE) {
if (m)
goto dontblock;
else
goto release;
}
for (; m; m = m->m_next)
if (m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)) {
m = so->so_rcv.sb_mb;
goto dontblock;
}
if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
(so->so_proto->pr_flags & PR_CONNREQUIRED)) {
error = ENOTCONN;
goto release;
}
if (resid == 0)
goto release;
if ((so->so_state & SS_NBIO) ||
(flags & (MSG_DONTWAIT|MSG_NBIO))) {
error = EWOULDBLOCK;
goto release;
}
sbunlock(&so->so_rcv);
error = sbwait(&so->so_rcv);
if (error) {
sounlock(so);
return (error);
}
goto restart;
}
dontblock:
/*
* On entry here, m points to the first record of the socket buffer.
* While we process the initial mbufs containing address and control
* info, we save a copy of m->m_nextpkt into nextrecord.
*/
#ifdef notyet /* XXXX */
if (uio->uio_lwp)
uio->uio_lwp->l_ru.ru_msgrcv++;
#endif
KASSERT(m == so->so_rcv.sb_mb);
SBLASTRECORDCHK(&so->so_rcv, "kttcp_soreceive 1");
SBLASTMBUFCHK(&so->so_rcv, "kttcp_soreceive 1");
nextrecord = m->m_nextpkt;
if (pr->pr_flags & PR_ADDR) {
#ifdef DIAGNOSTIC
if (m->m_type != MT_SONAME)
panic("receive 1a");
#endif
orig_resid = 0;
if (flags & MSG_PEEK) {
m = m->m_next;
} else {
sbfree(&so->so_rcv, m);
MFREE(m, so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}
}
while (m && m->m_type == MT_CONTROL && error == 0) {
if (flags & MSG_PEEK) {
m = m->m_next;
} else {
sbfree(&so->so_rcv, m);
MFREE(m, so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}
}
/*
* If m is non-NULL, we have some data to read. From now on,
* make sure to keep sb_lastrecord consistent when working on
* the last packet on the chain (nextrecord == NULL) and we
* change m->m_nextpkt.
*/
if (m) {
if ((flags & MSG_PEEK) == 0) {
m->m_nextpkt = nextrecord;
/*
* If nextrecord == NULL (this is a single chain),
* then sb_lastrecord may not be valid here if m
* was changed earlier.
*/
if (nextrecord == NULL) {
KASSERT(so->so_rcv.sb_mb == m);
so->so_rcv.sb_lastrecord = m;
}
}
type = m->m_type;
if (type == MT_OOBDATA)
flags |= MSG_OOB;
} else {
if ((flags & MSG_PEEK) == 0) {
KASSERT(so->so_rcv.sb_mb == m);
so->so_rcv.sb_mb = nextrecord;
SB_EMPTY_FIXUP(&so->so_rcv);
}
}
SBLASTRECORDCHK(&so->so_rcv, "kttcp_soreceive 2");
SBLASTMBUFCHK(&so->so_rcv, "kttcp_soreceive 2");
moff = 0;
offset = 0;
while (m && resid > 0 && error == 0) {
if (m->m_type == MT_OOBDATA) {
if (type != MT_OOBDATA)
break;
} else if (type == MT_OOBDATA)
break;
#ifdef DIAGNOSTIC
else if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
panic("receive 3");
#endif
so->so_state &= ~SS_RCVATMARK;
len = resid;
if (so->so_oobmark && len > so->so_oobmark - offset)
len = so->so_oobmark - offset;
if (len > m->m_len - moff)
len = m->m_len - moff;
/*
* If mp is set, just pass back the mbufs.
* Otherwise copy them out via the uio, then free.
* Sockbuf must be consistent here (points to current mbuf,
* it points to next record) when we drop priority;
* we must note any additions to the sockbuf when we
* block interrupts again.
*/
resid -= len;
if (len == m->m_len - moff) {
if (m->m_flags & M_EOR)
flags |= MSG_EOR;
if (flags & MSG_PEEK) {
m = m->m_next;
moff = 0;
} else {
nextrecord = m->m_nextpkt;
sbfree(&so->so_rcv, m);
if (mp) {
*mp = m;
mp = &m->m_next;
so->so_rcv.sb_mb = m = m->m_next;
*mp = NULL;
} else {
MFREE(m, so->so_rcv.sb_mb);
m = so->so_rcv.sb_mb;
}
/*
* If m != NULL, we also know that
* so->so_rcv.sb_mb != NULL.
*/
KASSERT(so->so_rcv.sb_mb == m);
if (m) {
m->m_nextpkt = nextrecord;
if (nextrecord == NULL)
so->so_rcv.sb_lastrecord = m;
} else {
so->so_rcv.sb_mb = nextrecord;
SB_EMPTY_FIXUP(&so->so_rcv);
}
SBLASTRECORDCHK(&so->so_rcv,
"kttcp_soreceive 3");
SBLASTMBUFCHK(&so->so_rcv,
"kttcp_soreceive 3");
}
} else {
if (flags & MSG_PEEK)
moff += len;
else {
if (mp) {
sounlock(so);
*mp = m_copym(m, 0, len, M_WAIT);
solock(so);
}
m->m_data += len;
m->m_len -= len;
so->so_rcv.sb_cc -= len;
}
}
if (so->so_oobmark) {
if ((flags & MSG_PEEK) == 0) {
so->so_oobmark -= len;
if (so->so_oobmark == 0) {
so->so_state |= SS_RCVATMARK;
break;
}
} else {
offset += len;
if (offset == so->so_oobmark)
break;
}
}
if (flags & MSG_EOR)
break;
/*
* If the MSG_WAITALL flag is set (for non-atomic socket),
* we must not quit until "uio->uio_resid == 0" or an error
* termination. If a signal/timeout occurs, return
* with a short count but without error.
* Keep sockbuf locked against other readers.
*/
while (flags & MSG_WAITALL && m == NULL && resid > 0 &&
!sosendallatonce(so) && !nextrecord) {
if (so->so_error || so->so_state & SS_CANTRCVMORE)
break;
/*
* If we are peeking and the socket receive buffer is
* full, stop since we can't get more data to peek at.
*/
if ((flags & MSG_PEEK) && sbspace(&so->so_rcv) <= 0)
break;
/*
* If we've drained the socket buffer, tell the
* protocol in case it needs to do something to
* get it filled again.
*/
if ((pr->pr_flags & PR_WANTRCVD) && so->so_pcb) {
(*pr->pr_usrreqs->pr_rcvd)(so, flags, l);
}
SBLASTRECORDCHK(&so->so_rcv,
"kttcp_soreceive sbwait 2");
SBLASTMBUFCHK(&so->so_rcv,
"kttcp_soreceive sbwait 2");
error = sbwait(&so->so_rcv);
if (error) {
sbunlock(&so->so_rcv);
sounlock(so);
return (0);
}
if ((m = so->so_rcv.sb_mb) != NULL)
nextrecord = m->m_nextpkt;
}
}
if (m && pr->pr_flags & PR_ATOMIC) {
flags |= MSG_TRUNC;
if ((flags & MSG_PEEK) == 0)
(void) sbdroprecord(&so->so_rcv);
}
if ((flags & MSG_PEEK) == 0) {
if (m == NULL) {
/*
* First part is an SB_EMPTY_FIXUP(). Second part
* makes sure sb_lastrecord is up-to-date if
* there is still data in the socket buffer.
*/
so->so_rcv.sb_mb = nextrecord;
if (so->so_rcv.sb_mb == NULL) {
so->so_rcv.sb_mbtail = NULL;
so->so_rcv.sb_lastrecord = NULL;
} else if (nextrecord->m_nextpkt == NULL)
so->so_rcv.sb_lastrecord = nextrecord;
}
SBLASTRECORDCHK(&so->so_rcv, "kttcp_soreceive 4");
SBLASTMBUFCHK(&so->so_rcv, "kttcp_soreceive 4");
if (pr->pr_flags & PR_WANTRCVD && so->so_pcb) {
(*pr->pr_usrreqs->pr_rcvd)(so, flags, l);
}
}
if (orig_resid == resid && orig_resid &&
(flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
sbunlock(&so->so_rcv);
goto restart;
}
if (flagsp)
*flagsp |= flags;
release:
sbunlock(&so->so_rcv);
sounlock(so);
*done = slen - resid;
#if 0
printf("soreceive: error %d slen %llu resid %lld\n", error, slen, resid);
#endif
return (error);
}
/*
* Slightly changed version of sosend()
*/
static int
kttcp_sosend(struct socket *so, unsigned long long slen,
unsigned long long *done, struct lwp *l, int flags)
{
struct mbuf **mp, *m, *top;
long space, len, mlen;
int error, dontroute, atomic;
long long resid;
atomic = sosendallatonce(so);
resid = slen;
top = NULL;
/*
* In theory resid should be unsigned.
* However, space must be signed, as it might be less than 0
* if we over-committed, and we must use a signed comparison
* of space and resid. On the other hand, a negative resid
* causes us to loop sending 0-length segments to the protocol.
*/
if (resid < 0) {
error = EINVAL;
goto out;
}
dontroute =
(flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
(so->so_proto->pr_flags & PR_ATOMIC);
l->l_ru.ru_msgsnd++;
#define snderr(errno) { error = errno; goto release; }
solock(so);
restart:
if ((error = sblock(&so->so_snd, SBLOCKWAIT(flags))) != 0)
goto out;
do {
if (so->so_state & SS_CANTSENDMORE)
snderr(EPIPE);
if (so->so_error) {
error = so->so_error;
so->so_error = 0;
goto release;
}
if ((so->so_state & SS_ISCONNECTED) == 0) {
if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
snderr(ENOTCONN);
} else {
snderr(EDESTADDRREQ);
}
}
space = sbspace(&so->so_snd);
if (flags & MSG_OOB)
space += 1024;
if ((atomic && resid > so->so_snd.sb_hiwat))
snderr(EMSGSIZE);
if (space < resid && (atomic || space < so->so_snd.sb_lowat)) {
if (so->so_state & SS_NBIO)
snderr(EWOULDBLOCK);
SBLASTRECORDCHK(&so->so_rcv,
"kttcp_soreceive sbwait 1");
SBLASTMBUFCHK(&so->so_rcv,
"kttcp_soreceive sbwait 1");
sbunlock(&so->so_snd);
error = sbwait(&so->so_snd);
if (error)
goto out;
goto restart;
}
mp = ⊤
do {
sounlock(so);
do {
if (top == 0) {
m = m_gethdr(M_WAIT, MT_DATA);
mlen = MHLEN;
m->m_pkthdr.len = 0;
m->m_pkthdr.rcvif = NULL;
} else {
m = m_get(M_WAIT, MT_DATA);
mlen = MLEN;
}
if (resid >= MINCLSIZE && space >= MCLBYTES) {
m_clget(m, M_WAIT);
if ((m->m_flags & M_EXT) == 0)
goto nopages;
mlen = MCLBYTES;
#ifdef MAPPED_MBUFS
len = lmin(MCLBYTES, resid);
#else
if (atomic && top == 0) {
len = lmin(MCLBYTES - max_hdr,
resid);
m->m_data += max_hdr;
} else
len = lmin(MCLBYTES, resid);
#endif
space -= len;
} else {
nopages:
len = lmin(lmin(mlen, resid), space);
space -= len;
/*
* For datagram protocols, leave room
* for protocol headers in first mbuf.
*/
if (atomic && top == 0 && len < mlen)
MH_ALIGN(m, len);
}
resid -= len;
m->m_len = len;
*mp = m;
top->m_pkthdr.len += len;
if (error)
goto release;
mp = &m->m_next;
if (resid <= 0) {
if (flags & MSG_EOR)
top->m_flags |= M_EOR;
break;
}
} while (space > 0 && atomic);
solock(so);
if (so->so_state & SS_CANTSENDMORE)
snderr(EPIPE);
if (dontroute)
so->so_options |= SO_DONTROUTE;
if (resid > 0)
so->so_state |= SS_MORETOCOME;
if (flags & MSG_OOB)
error = (*so->so_proto->pr_usrreqs->pr_sendoob)(so,
top, NULL);
else
error = (*so->so_proto->pr_usrreqs->pr_send)(so,
top, NULL, NULL, l);
if (dontroute)
so->so_options &= ~SO_DONTROUTE;
if (resid > 0)
so->so_state &= ~SS_MORETOCOME;
top = 0;
mp = ⊤
if (error)
goto release;
} while (resid && space > 0);
} while (resid);
release:
sbunlock(&so->so_snd);
out:
sounlock(so);
if (top)
m_freem(top);
*done = slen - resid;
#if 0
printf("sosend: error %d slen %llu resid %lld\n", error, slen, resid);
#endif
return (error);
}
BOOL CALLBACK ADDBLOCKMsgProc(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam)
{
typedef struct STATSStruct
{
float dhdDist;
long dhdTime;
long layTime;
float revDist;
long revTime;
} STATSDef;
typedef struct PARMSStruct
{
BOOL bStandard;
BOOL bDropback;
BOOL bInterlining;
BOOL bServiceWrap;
BOOL bDeadheading;
BOOL bDeadheadAll;
long maxDeadheadTime;
} PARMSDef;
static PDISPLAYINFO pDI;
static HANDLE hCtlALLROUTES;
static HANDLE hCtlCC;
static HANDLE hCtlCOMMENTCODE;
static HANDLE hCtlORROUTE;
static HANDLE hCtlFROMROUTE;
static HANDLE hCtlFROMSERVICE;
static HANDLE hCtlLISTBOXTITLE;
static HANDLE hCtlTRIPS;
static HANDLE hCtlMIN;
static HANDLE hCtlMINVEHICLES;
static HANDLE hCtlMAX;
static HANDLE hCtlMAXVEHICLES;
static HANDLE hCtlILYES;
static HANDLE hCtlILNO;
static HANDLE hCtlSWYES;
static HANDLE hCtlSWNO;
static HANDLE hCtlDHYES;
static HANDLE hCtlDHNO;
static HANDLE hCtlDEADHEADALL;
static HANDLE hCtlDEADHEADTHOSE;
static HANDLE hCtlDEADHEADMINS;
static HANDLE hCtlTEXT_MINUTES;
static HANDLE hCtlIDREMOVE;
static HANDLE hCtlIDPREVIEW;
static HANDLE hCtlIDOPTIMAL;
static HANDLE hCtlIDMANUAL;
static HANDLE hCtlSTANDARD;
static HANDLE hCtlDROPBACK;
static HANDLE hCtlDEADHEADSTOUSE;
static int tabPos[TABSET] = {32};
GenerateTripDef GTResults;
GetConnectionTimeDef GCTData;
PARMSDef PARMS;
BLOCKSDef *pTRIPSChunk;
LAYOVERDef *pLayover;
float distance;
short int wmId;
short int wmEvent;
BOOL bFound;
BOOL bEnable;
BOOL bAbort;
char routeName[ROUTES_NAME_LENGTH + 1];
char routeNumber[ROUTES_NUMBER_LENGTH + 1];
char serviceName[SERVICES_NAME_LENGTH + 1];
long fromRouteRecordID;
long fromServiceRecordID;
long lastBlock;
long minutes;
long percent;
long tempLong;
long minVehicles;
long maxVehicles;
long commentRecordID;
long position;
long flags;
long dhd;
WORD DlgWidthUnits;
int adjustedTabPos[TABSET];
int nI;
int nJ;
int nK;
int nRc;
int rcode2;
int numRoutes;
int numTrips;
int maxTrips;
int numComments;
int numSelected;
int fromRoutePosition;
int fromServicePosition;
int blockingType;
int layoverType;
long *pTRIPSrecordIDs = NULL;
int *pSelected = NULL;
switch(Message)
{
//
// WM_INITDIALOG - Initialize the dialog
//
case WM_INITDIALOG:
pDI = (PDISPLAYINFO)lParam;
if(pDI == NULL)
{
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM)0);
break;
}
m_numConnectionAlerts = 0;
//
// Set up some control handles for later use
//
hCtlALLROUTES = GetDlgItem(hWndDlg, ADDBLOCK_ALLROUTES);
hCtlCC = GetDlgItem(hWndDlg, ADDBLOCK_CC);
hCtlCOMMENTCODE = GetDlgItem(hWndDlg, ADDBLOCK_COMMENTCODE);
hCtlORROUTE = GetDlgItem(hWndDlg, ADDBLOCK_ORROUTE);
hCtlFROMROUTE = GetDlgItem(hWndDlg, ADDBLOCK_FROMROUTE);
hCtlFROMSERVICE = GetDlgItem(hWndDlg, ADDBLOCK_FROMSERVICE);
hCtlLISTBOXTITLE = GetDlgItem(hWndDlg, ADDBLOCK_LISTBOXTITLE);
hCtlTRIPS = GetDlgItem(hWndDlg, ADDBLOCK_TRIPS);
hCtlMIN = GetDlgItem(hWndDlg, ADDBLOCK_MIN);
hCtlMINVEHICLES = GetDlgItem(hWndDlg, ADDBLOCK_MINVEHICLES);
hCtlMAX = GetDlgItem(hWndDlg, ADDBLOCK_MAX);
hCtlMAXVEHICLES = GetDlgItem(hWndDlg, ADDBLOCK_MAXVEHICLES);
hCtlILYES = GetDlgItem(hWndDlg, ADDBLOCK_ILYES);
hCtlILNO = GetDlgItem(hWndDlg, ADDBLOCK_ILNO);
hCtlSWYES = GetDlgItem(hWndDlg, ADDBLOCK_SWYES);
hCtlSWNO = GetDlgItem(hWndDlg, ADDBLOCK_SWNO);
hCtlDHYES = GetDlgItem(hWndDlg, ADDBLOCK_DHYES);
hCtlDHNO = GetDlgItem(hWndDlg, ADDBLOCK_DHNO);
hCtlDEADHEADALL = GetDlgItem(hWndDlg, ADDBLOCK_DEADHEADALL);
hCtlDEADHEADTHOSE = GetDlgItem(hWndDlg, ADDBLOCK_DEADHEADTHOSE);
hCtlDEADHEADMINS = GetDlgItem(hWndDlg, ADDBLOCK_DEADHEADMINS);
hCtlTEXT_MINUTES = GetDlgItem(hWndDlg, ADDBLOCK_TEXT_MINUTES);
hCtlIDREMOVE = GetDlgItem(hWndDlg, IDREMOVE);
hCtlIDPREVIEW = GetDlgItem(hWndDlg, IDPREVIEW);
hCtlIDOPTIMAL = GetDlgItem(hWndDlg, IDOPTIMAL);
hCtlIDMANUAL = GetDlgItem(hWndDlg, IDMANUAL);
hCtlSTANDARD = GetDlgItem(hWndDlg, ADDBLOCK_STANDARD);
hCtlDROPBACK = GetDlgItem(hWndDlg, ADDBLOCK_DROPBACK);
hCtlDEADHEADSTOUSE = GetDlgItem(hWndDlg, ADDBLOCK_DEADHEADSTOUSE);
//
// Set up the tab stops for ADDBLOCK_LISTBOXTITLE and ADDBLOCK_TRIPS
//
DlgWidthUnits = LOWORD(GetDialogBaseUnits()) / 4;
for(nJ = 0; nJ < TABSET; nJ++)
{
adjustedTabPos[nJ] = (DlgWidthUnits * tabPos[nJ] * 2);
}
SendMessage(hCtlLISTBOXTITLE, LB_SETTABSTOPS, (WPARAM)TABSET, (LPARAM)adjustedTabPos);
LoadString(hInst, TEXT_019, tempString, TEMPSTRING_LENGTH);
SendMessage(hCtlLISTBOXTITLE, LB_ADDSTRING, 0, (LONG)(LPSTR)tempString);
SendMessage(hCtlTRIPS, LB_SETTABSTOPS, (WPARAM)TABSET, (LPARAM)adjustedTabPos);
//
// Default to all routes and this service
//
SendMessage(hCtlALLROUTES, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
if(SetUpServiceList(hWndDlg, ADDBLOCK_FROMSERVICE, pDI->fileInfo.serviceRecordID) == 0)
{
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM)0);
break;
}
//
// Set up the route listbox
//
numRoutes = 0;
SendMessage(hCtlFROMROUTE, LB_RESETCONTENT, (WPARAM)(WPARAM)0, (LPARAM)0);
rcode2 = btrieve(B_GETFIRST, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
while(rcode2 == 0)
{
strncpy(tempString, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(tempString, ROUTES_NUMBER_LENGTH);
strncpy(szarString, ROUTES.name, ROUTES_NAME_LENGTH);
trim(szarString, ROUTES_NAME_LENGTH);
strcat(tempString, " - ");
strcat(tempString, szarString);
nI = (int)SendMessage(hCtlFROMROUTE, LB_ADDSTRING, (WPARAM)0, (LONG)(LPSTR)tempString);
SendMessage(hCtlFROMROUTE, LB_SETITEMDATA, (WPARAM)nI, ROUTES.recordID);
numRoutes++;
rcode2 = btrieve(B_GETNEXT, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
}
if(numRoutes == 0)
{
TMSError(hWndDlg, MB_ICONSTOP, ERROR_008, (HANDLE)NULL);
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL,0), (LPARAM)0);
break;
}
//
// Comment codes combo box
//
numComments = SetUpCommentList(hWndDlg, ADDBLOCK_COMMENTCODE);
if(numComments == 0)
{
EnableWindow(hCtlCC, FALSE);
EnableWindow(hCtlCOMMENTCODE, FALSE);
}
//
// Default to "Min" vechicle requirements, but with a blank field
//
SendMessage(hCtlMIN, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
SendMessage(hCtlMINVEHICLES, WM_SETTEXT, (WPARAM)0, (LONG)(LPSTR)"");
//
// Default to allowing deadheading, service wraps, and interlining
//
SendMessage(hCtlILYES, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
SendMessage(hCtlSWYES, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
SendMessage(hCtlDHYES, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
SendMessage(hCtlDEADHEADALL, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
//
// Clear out edit controls associated with a spin control
//
SendMessage(hCtlDEADHEADMINS, WM_SETTEXT, (WPARAM)0, (LONG)(LPSTR)"");
//
// Default to this table's blocking technique
//
if(pDI->fileInfo.fileNumber == TMS_STANDARDBLOCKS)
{
SendMessage(hCtlSTANDARD, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
EnableWindow(hCtlDROPBACK, FALSE);
}
else
{
SendMessage(hCtlDROPBACK, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
EnableWindow(hCtlSTANDARD, FALSE);
}
//
// Set up the m_pPICKEDTRIPS structure
//
if(m_pPICKEDTRIPS == NULL)
{
m_pPICKEDTRIPS = (PICKEDTRIPSDef *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PICKEDTRIPSDef) * m_maxPICKEDTRIPS);
if(m_pPICKEDTRIPS == NULL)
{
AllocationError(__FILE__, __LINE__, FALSE);
goto OptimalBlockCleanup;
}
}
//
// Set up the "destination"
//
flags = PLACEMENT_ROUTE | PLACEMENT_SERVICE;
DisplayPlacement(hWndDlg, ADDBLOCK_DESTINATION, pDI, flags);
break;
//
// WM_CLOSE
//
case WM_CLOSE:
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM)0);
break;
//
// WM_COMMAND
//
// Note: The outbound and inbound direction buttons get
// disabled when the route is set to "All routes"
//
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
switch(wmId)
{
//
// ADDBLOCK_ALLROUTES radio button
//
case ADDBLOCK_ALLROUTES:
SendMessage(hCtlFROMROUTE, LB_SETSEL, (WPARAM)(FALSE), (LPARAM)(-1));
SendMessage(hCtlCOMMENTCODE, CB_SETCURSEL, (WPARAM)(-1), (LPARAM)0);
break;
//
// ADDBLOCK_CC radio button
//
case ADDBLOCK_CC:
SendMessage(hCtlCOMMENTCODE, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);
break;
//
// ADDBLOCK_ORROUTE radio button
//
case ADDBLOCK_ORROUTE:
SendMessage(hCtlCOMMENTCODE, CB_SETCURSEL, (WPARAM)(-1), (LPARAM)0);
nI = (int)SendMessage(hCtlFROMROUTE, LB_GETCURSEL, (WPARAM)0, (LPARAM)0);
if(nI == CB_ERR)
{
nJ = (int)SendMessage(hCtlFROMROUTE, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);
if(nJ == 0)
break;
for(nI = 0; nI < nJ; nI++)
{
tempLong = SendMessage(hCtlFROMROUTE, LB_GETITEMDATA, (WPARAM)nI, (LPARAM)0);
if(tempLong == pDI->fileInfo.routeRecordID)
{
SendMessage(hCtlFROMROUTE, LB_SETCURSEL, (WPARAM)nI, (LPARAM)0);
break;
}
}
}
//
// ADDBLOCK_FROMROUTE listbox
//
case ADDBLOCK_FROMROUTE:
switch(wmEvent)
{
case LBN_SELCHANGE:
if(SendMessage(hCtlALLROUTES, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
SendMessage(hCtlALLROUTES, BM_SETCHECK, (WPARAM)FALSE, (LPARAM)0);
SendMessage(hCtlORROUTE, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
}
break;
}
break;
//
// ADDBLOCK_LISTBOXTITLE
//
case ADDBLOCK_LISTBOXTITLE: // Title string
SendMessage(hCtlLISTBOXTITLE, LB_SETSEL, (WPARAM)FALSE, (LPARAM)(-1));
break;
//
// ADDBLOCK_TRIPS
//
case ADDBLOCK_TRIPS: // List box
switch(wmEvent)
{
case LBN_SELCHANGE:
case LBN_SELCANCEL:
bEnable = SendMessage(hCtlTRIPS, LB_GETSELCOUNT, (WPARAM)0, (LPARAM)0) > 0;
EnableWindow(hCtlIDREMOVE, bEnable);
EnableWindow(hCtlIDPREVIEW, bEnable);
break;
case LBN_DBLCLK:
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDPREVIEW, 0), (LPARAM)0);
EnableWindow(hCtlIDPREVIEW, TRUE);
break;
}
break;
//
// ADDBLOCK_MIN
//
case ADDBLOCK_MIN:
EnableWindow(hCtlMINVEHICLES, TRUE);
EnableWindow(hCtlMAXVEHICLES, FALSE);
break;
//
// ADDBLOCK_MAX
//
case ADDBLOCK_MAX:
EnableWindow(hCtlMINVEHICLES, FALSE);
EnableWindow(hCtlMAXVEHICLES, TRUE);
break;
//
// ADDBLOCK_DHYES / ADDBLOCK_DHNO
//
case ADDBLOCK_DHYES:
case ADDBLOCK_DHNO:
bEnable = SendMessage(hCtlDHYES, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
EnableWindow(hCtlDEADHEADALL, bEnable);
EnableWindow(hCtlDEADHEADSTOUSE, bEnable);
EnableWindow(hCtlDEADHEADTHOSE, bEnable);
EnableWindow(hCtlDEADHEADMINS, bEnable);
EnableWindow(hCtlTEXT_MINUTES, bEnable);
break;
//
// IDPREVIEW
//
case IDPREVIEW: // Button text: "Preview"
nI = SendMessage(hCtlTRIPS, LB_GETSELCOUNT, (WPARAM)0, (LPARAM)0);
if(nI == 0 || nI == LB_ERR)
{
break;
}
pSelected = (int *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(int) * nI);
if(pSelected == NULL)
{
AllocationError(__FILE__, __LINE__, FALSE);
break;
}
numSelected = (int)SendMessage(hCtlTRIPS, LB_GETSELITEMS, (WPARAM)nI, (LPARAM)pSelected);
if(numSelected >= m_maxPICKEDTRIPS)
{
m_maxPICKEDTRIPS += (numSelected + 1);
m_pPICKEDTRIPS = (PICKEDTRIPSDef *)HeapReAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, m_pPICKEDTRIPS, sizeof(PICKEDTRIPSDef) * m_maxPICKEDTRIPS);
if(m_pPICKEDTRIPS == NULL)
{
AllocationError(__FILE__, __LINE__, TRUE);
break;
}
}
for(nI = 0; nI < numSelected; nI++)
{
position = SendMessage(hCtlTRIPS, LB_GETITEMDATA, (WPARAM)pSelected[nI], (LPARAM)0);
fromRoutePosition = LOWORD(position);
fromServicePosition = HIWORD(position);
m_pPICKEDTRIPS[nI].ROUTESrecordID = SendMessage(hCtlFROMROUTE,
LB_GETITEMDATA, (WPARAM)fromRoutePosition, (LPARAM)0);
m_pPICKEDTRIPS[nI].SERVICESrecordID = SendMessage(hCtlFROMSERVICE,
CB_GETITEMDATA, (WPARAM)fromServicePosition, (LPARAM)0);
}
DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_PREVIEWT),
hWndDlg, (DLGPROC)PREVIEWTMsgProc, (LPARAM)numSelected);
TMSHeapFree(pSelected);
break;
//
// IDADD
//
case IDADD: // Button text: "&Add Trip(s)"
//
// Get the service
//
fromServicePosition =
(int)SendMessage(hCtlFROMSERVICE, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
if(fromServicePosition == CB_ERR)
{
break;
}
fromServiceRecordID =
SendMessage(hCtlFROMSERVICE, CB_GETITEMDATA, (WPARAM)fromServicePosition, (LPARAM)0);
SERVICESKey0.recordID = fromServiceRecordID;
btrieve(B_GETEQUAL, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
strncpy(serviceName, SERVICES.name, SERVICES_NAME_LENGTH);
trim(serviceName, SERVICES_NAME_LENGTH);
//
// Get the route(s)
//
// All
//
if(SendMessage(hCtlALLROUTES, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
SendMessage(hCtlFROMROUTE, LB_SETSEL, (WPARAM)(TRUE), (LPARAM)(-1));
}
//
// Those labelled...
//
else if(SendMessage(hCtlCC, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
nK = (int)SendMessage(hCtlCOMMENTCODE, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
commentRecordID = (nK == CB_ERR ? NO_RECORD :
SendMessage(hCtlCOMMENTCODE, CB_GETITEMDATA, (WPARAM)nK, (LPARAM)0));
if(commentRecordID == NO_RECORD)
{
break;
}
nJ = (int)SendMessage(hCtlFROMROUTE, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);
for(nI = 0; nI < nJ; nI++)
{
ROUTESKey0.recordID = SendMessage(hCtlFROMROUTE, LB_GETITEMDATA, (WPARAM)nI, (LPARAM)0);
rcode2 = btrieve(B_GETEQUAL, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
if(ROUTES.COMMENTSrecordID == commentRecordID)
{
SendMessage(hCtlFROMROUTE, LB_SETSEL, (WPARAM)TRUE, (LPARAM)nI);
}
}
}
//
// Got the selections - continue
//
nI = (int)SendMessage(hCtlFROMROUTE, LB_GETSELCOUNT, (WPARAM)0, (LPARAM)0);
if(nI == 0 || nI == LB_ERR)
{
break;
}
pSelected = (int *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(int) * nI);
if(pSelected == NULL)
{
AllocationError(__FILE__, __LINE__, FALSE);
break;
}
numSelected = (int)SendMessage(hCtlFROMROUTE, LB_GETSELITEMS, (WPARAM)nI, (LPARAM)pSelected);
//
// Add the results to the "to be blocked" list box
//
for(nI = 0; nI < numSelected; nI++)
{
fromRoutePosition = pSelected[nI];
fromRouteRecordID = SendMessage(hCtlFROMROUTE, LB_GETITEMDATA, (WPARAM)fromRoutePosition, (LPARAM)0);
//
// Before we go any further, let's see if we've got this one already
//
position = MAKELONG(fromRoutePosition, fromServicePosition);
nJ = SendMessage(hCtlTRIPS, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);
for(bFound = FALSE, nK = 0; nK < nJ; nK++)
{
tempLong = SendMessage(hCtlTRIPS, LB_GETITEMDATA, (WPARAM)nK, (LPARAM)0);
if(tempLong == position)
{
bFound = TRUE;
break;
}
}
if(bFound)
{
continue;
}
//
// Not found
//
EnableWindow(hCtlIDOPTIMAL, TRUE);
EnableWindow(hCtlIDMANUAL, TRUE);
//
// Display it
//
ROUTESKey0.recordID = fromRouteRecordID;
btrieve(B_GETEQUAL, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
strncpy(routeNumber, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(routeNumber, ROUTES_NUMBER_LENGTH);
strncpy(routeName, ROUTES.name, ROUTES_NAME_LENGTH);
trim(routeName, ROUTES_NAME_LENGTH);
strcpy(tempString, routeNumber);
strcat(tempString, " - ");
strcat(tempString, routeName);
tempString[tabPos[0]] = '\0';
strcat(tempString, "\t");
strcat(tempString, serviceName);
nK = (int)SendMessage(hCtlTRIPS, LB_ADDSTRING, (WPARAM)0, (LONG)(LPSTR)tempString);
SendMessage(hCtlTRIPS, LB_SETITEMDATA, (WPARAM)nK, (LPARAM)position);
}
SendMessage(hCtlFROMROUTE, LB_SETSEL, (WPARAM)FALSE, (LPARAM)(-1));
TMSHeapFree(pSelected);
break;
//
// IDREMOVE
//
case IDREMOVE: // Button text: "Remove"
nI = (int)SendMessage(hCtlTRIPS, LB_GETSELCOUNT, (WPARAM)0, (LPARAM)0);
if(nI == 0 || nI == LB_ERR)
{
break;
}
pSelected = (int *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(int) * nI);
if(pSelected == NULL)
{
AllocationError(__FILE__, __LINE__, FALSE);
break;
}
numSelected = (int)SendMessage(hCtlTRIPS, LB_GETSELITEMS, (WPARAM)nI, (LPARAM)pSelected);
//
// Process the list from the back to the front
//
for(nI = numSelected - 1; nI >= 0; nI--)
{
SendMessage(hCtlTRIPS, LB_DELETESTRING, (WPARAM)pSelected[nI], (LPARAM)0);
}
if(SendMessage(hCtlTRIPS, LB_GETCOUNT, (WPARAM)0, (LPARAM)0) == 0)
{
EnableWindow(hCtlIDOPTIMAL, FALSE);
EnableWindow(hCtlIDMANUAL, FALSE);
}
EnableWindow(hCtlIDREMOVE, FALSE);
EnableWindow(hCtlIDPREVIEW, FALSE);
TMSHeapFree(pSelected);
break;
//
// IDCANCEL
//
case IDCANCEL:
EndDialog(hWndDlg, FALSE);
break;
//
// IDHELP
//
case IDHELP:
WinHelp(hWndDlg, szarHelpFile, HELP_CONTEXT, The_Standard_Blocks_Table);
break;
//
// IDMANUAL and IDOPTIMAL
//
case IDMANUAL:
case IDOPTIMAL:
m_bNetworkMode = FALSE;
//
// Get the parameters
//
PARMS.bStandard = SendMessage(hCtlSTANDARD, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
PARMS.bDropback = SendMessage(hCtlDROPBACK, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
//
// Standard and Dropback are mutually exclusive on a manual block
//
if(wmId == IDMANUAL)
{
if(PARMS.bStandard && PARMS.bDropback)
{
TMSError(hWndDlg, MB_ICONSTOP, ERROR_134, hCtlSTANDARD);
break;
}
}
//
// At least one of Standard or Dropback must be chosen prior to pressing Optimal
//
else
{
if(!PARMS.bStandard && !PARMS.bDropback)
{
TMSError(hWndDlg, MB_ICONSTOP, ERROR_135, hCtlSTANDARD);
break;
}
}
//
// Get the rest of the parameters
//
PARMS.bInterlining = SendMessage(hCtlILYES, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
PARMS.bServiceWrap = SendMessage(hCtlSWYES, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
PARMS.bDeadheading = SendMessage(hCtlDHYES, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
if(!PARMS.bDeadheading)
{
PARMS.bDeadheadAll = FALSE;
PARMS.maxDeadheadTime = NO_TIME;
}
else
{
SendMessage(hCtlDEADHEADMINS, WM_GETTEXT,
(WPARAM)TEMPSTRING_LENGTH, (LONG)(LPSTR)tempString);
if(strcmp(tempString, "") == 0)
{
PARMS.bDeadheadAll = TRUE;
PARMS.maxDeadheadTime = NO_TIME;
}
else
{
PARMS.bDeadheadAll = FALSE;
PARMS.maxDeadheadTime = atol(tempString) * 60;
}
}
//
// Build the list of selected trips
//
m_numPICKEDTRIPS = SendMessage(hCtlTRIPS, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);
if(m_numPICKEDTRIPS >= m_maxPICKEDTRIPS)
{
m_maxPICKEDTRIPS += (m_numPICKEDTRIPS + 1);
m_pPICKEDTRIPS = (PICKEDTRIPSDef *)HeapReAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, m_pPICKEDTRIPS, sizeof(PICKEDTRIPSDef) * m_maxPICKEDTRIPS);
if(m_pPICKEDTRIPS == NULL)
{
AllocationError(__FILE__, __LINE__, TRUE);
break;
}
}
for(nI = 0; nI < m_numPICKEDTRIPS; nI++)
{
position = SendMessage(hCtlTRIPS, LB_GETITEMDATA, (WPARAM)nI, (LPARAM)0);
fromRoutePosition = LOWORD(position);
fromServicePosition = HIWORD(position);
m_pPICKEDTRIPS[nI].ROUTESrecordID = SendMessage(hCtlFROMROUTE,
LB_GETITEMDATA, (WPARAM)fromRoutePosition, (LPARAM)0);
m_pPICKEDTRIPS[nI].SERVICESrecordID = SendMessage(hCtlFROMSERVICE,
CB_GETITEMDATA, (WPARAM)fromServicePosition, (LPARAM)0);
}
//
// Dropback blocking isn't permitted unless it's been "standard" blocked already
//
if(PARMS.bDropback)
{
bAbort = FALSE;
for(nI = 0; nI < m_numPICKEDTRIPS; nI++)
{
if(bAbort)
break;
for(nJ = 0; nJ < 2; nJ++)
{
if(bAbort)
break;
ROUTESKey0.recordID = m_pPICKEDTRIPS[nI].ROUTESrecordID;
btrieve(B_GETEQUAL, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
if(ROUTES.DIRECTIONSrecordID[nJ] == NO_RECORD)
continue;
TRIPSKey1.ROUTESrecordID = m_pPICKEDTRIPS[nI].ROUTESrecordID;
TRIPSKey1.SERVICESrecordID = m_pPICKEDTRIPS[nI].SERVICESrecordID;
TRIPSKey1.directionIndex = nJ;
TRIPSKey1.tripSequence = NO_TIME;
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
while(rcode2 == 0 &&
TRIPS.ROUTESrecordID == m_pPICKEDTRIPS[nI].ROUTESrecordID &&
TRIPS.SERVICESrecordID == m_pPICKEDTRIPS[nI].SERVICESrecordID &&
TRIPS.directionIndex == nJ)
{
if(TRIPS.standard.blockNumber == 0)
{
LoadString(hInst, TEXT_245, szFormatString, sizeof(szFormatString));
strncpy(routeNumber, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(routeNumber, ROUTES_NUMBER_LENGTH);
strncpy(routeName, ROUTES.name, ROUTES_NAME_LENGTH);
trim(routeName, ROUTES_NAME_LENGTH);
SERVICESKey0.recordID = m_pPICKEDTRIPS[nI].SERVICESrecordID;
btrieve(B_GETEQUAL, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
strncpy(serviceName, SERVICES.name, SERVICES_NAME_LENGTH);
trim(serviceName, SERVICES_NAME_LENGTH);
sprintf(tempString, szFormatString, serviceName, routeNumber, routeName);
MessageBeep(MB_ICONSTOP);
MessageBox(hWndDlg, tempString, TMS, MB_OK);
bAbort = TRUE;
break;
}
rcode2 = btrieve(B_GETNEXT, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
}
}
}
if(bAbort)
break;
}
//
// IDMANUAL - Go into MANBLOCK
//
if(wmId == IDMANUAL)
{
pDI->otherData = (long)(&PARMS);
nRc = BlockDialog(pDI);
if(nRc)
{
EndDialog(hWndDlg, TRUE);
}
break;
}
//
// IDOPTIMAL
//
for(blockingType = 0; blockingType < 2; blockingType++)
{
if(blockingType == 0)
{
if(!PARMS.bStandard)
{
continue;
}
StatusBarStart(hWndDlg, "Optimal Standard Blocking Status");
pTRIPSChunk = &TRIPS.standard;
pLayover = &StandardLayover;
layoverType = TMS_STANDARDBLOCKS;
}
else
{
if(!PARMS.bDropback)
{
continue;
}
StatusBarStart(hWndDlg, "Optimal Dropback Blocking Status");
pTRIPSChunk = &TRIPS.dropback;
pLayover = &DropbackLayover;
layoverType = TMS_DROPBACKBLOCKS;
}
StatusBar(-1L, -1L);
StatusBarText("Initializing...");
//
// Initialize the interlining option
//
BLSetOptions(SendMessage(hCtlILYES, BM_GETCHECK, (WPARAM)0, (LPARAM)0));
//
// Loop through numPICKEDTRIPS to determine what we're dealing with
//
StatusBarText("Examining selected trips...");
m_numConnectionAlerts = 0;
maxTrips = 512;
pTRIPSrecordIDs = (long *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(long) * maxTrips);
if(pTRIPSrecordIDs == NULL)
{
AllocationError(__FILE__, __LINE__, FALSE);
goto OptimalBlockCleanup;
}
for(numTrips = 0, nI = 0; nI < m_numPICKEDTRIPS; nI++)
{
StatusBar((long)nI, (long)m_numPICKEDTRIPS);
if(StatusBarAbort())
{
goto OptimalBlockCleanup;
}
m_bEstablishRUNTIMES = TRUE;
TRIPSKey1.ROUTESrecordID = m_pPICKEDTRIPS[nI].ROUTESrecordID;
TRIPSKey1.SERVICESrecordID = m_pPICKEDTRIPS[nI].SERVICESrecordID;
TRIPSKey1.directionIndex = NO_RECORD;
TRIPSKey1.tripSequence = NO_RECORD;
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
while(rcode2 == 0 &&
(m_pPICKEDTRIPS[nI].ROUTESrecordID == NO_RECORD ||
TRIPS.ROUTESrecordID == m_pPICKEDTRIPS[nI].ROUTESrecordID) &&
(m_pPICKEDTRIPS[nI].SERVICESrecordID == NO_RECORD ||
TRIPS.SERVICESrecordID == m_pPICKEDTRIPS[nI].SERVICESrecordID))
{
if(pTRIPSChunk->blockNumber == 0)
{
if(numTrips >= maxTrips)
{
maxTrips += 512;
pTRIPSrecordIDs = (long *)HeapReAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, pTRIPSrecordIDs, sizeof(long) * maxTrips);
if(pTRIPSrecordIDs == NULL)
{
AllocationError(__FILE__, __LINE__, TRUE);
goto OptimalBlockCleanup;
}
}
pTRIPSrecordIDs[numTrips++] = TRIPS.recordID;
}
rcode2 = btrieve(B_GETNEXT, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
}
}
if((m_numTripsForBlocker = numTrips) == 0)
{
TMSError(hWndDlg, MB_ICONSTOP, ERROR_102, (HANDLE)NULL);
goto OptimalBlockCleanup;
}
//
// If m_numConnectionAlerts is non-zero, blow him off
//
if(m_numConnectionAlerts != 0)
{
TMSError(hWndDlg, MB_ICONSTOP, ERROR_173, (HANDLE)NULL);
goto OptimalBlockCleanup;
}
//
// Make sure that we're not going in with bad values for min & max layover
//
if(pLayover->minimum.type == NO_RECORD ||
pLayover->maximum.type == NO_RECORD ||
(pLayover->maximum.type == 0 && pLayover->maximum.minutes == 0))
{
MessageBeep(MB_ICONSTOP);
LoadString(hInst, ERROR_030, szarString, sizeof(szarString));
MessageBox(hWndDlg, szarString, TMS, MB_ICONSTOP);
nRc = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_LAYOVER),
hWndDlg, (DLGPROC)LAYOVERMsgProc, (LPARAM)layoverType);
if(!nRc)
goto OptimalBlockCleanup;
}
//
// Generate trip data into TRIPINFO
//
StatusBarText("Building trip data...");
StatusBar(0L, 0L);
BLInitNetwork();
for(nI = 0; nI < numTrips; nI++)
{
StatusBar((long)nI, (long)numTrips);
if(StatusBarAbort())
goto OptimalBlockCleanup;
TRIPSKey0.recordID = pTRIPSrecordIDs[nI];
btrieve(B_GETEQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey0, 0);
nJ = GenerateTrip(TRIPS.ROUTESrecordID, TRIPS.SERVICESrecordID,
TRIPS.directionIndex, TRIPS.PATTERNNAMESrecordID,
TRIPS.timeAtMLP, GENERATETRIP_FLAG_DISPLAYERRORS, >Results);
//
// If we've got a one-node trip, fool the blocker
//
if(GTResults.firstNODESrecordID == GTResults.lastNODESrecordID &&
GTResults.firstNodeTime == GTResults.lastNodeTime)
{
GTResults.lastNodeTime++;
}
if(nJ != 0)
{
TRIPINFODef TRIPINFOrec;
TRIPINFOrec.TRIPSrecordID = TRIPS.recordID;
TRIPINFOrec.BUSTYPESrecordID = TRIPS.BUSTYPESrecordID;
TRIPINFOrec.ROUTESrecordID = TRIPS.ROUTESrecordID;
//
// If we're doing a dropback, and the standard block pulls out or in,
// then replace the start/end node/time with the pullout/in gar/time.
//
// Check pullouts
//
if(PARMS.bStandard || TRIPS.standard.POGNODESrecordID == NO_RECORD)
{
TRIPINFOrec.startNODESrecordID = GTResults.firstNODESrecordID;
TRIPINFOrec.startTime = GTResults.firstNodeTime;
}
else
{
GCTData.fromPATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
GCTData.toPATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
GCTData.fromROUTESrecordID = TRIPS.ROUTESrecordID;
GCTData.fromSERVICESrecordID = TRIPS.SERVICESrecordID;
GCTData.toROUTESrecordID = TRIPS.ROUTESrecordID;
GCTData.toSERVICESrecordID = TRIPS.SERVICESrecordID;
GCTData.fromNODESrecordID = TRIPS.standard.POGNODESrecordID;
GCTData.toNODESrecordID = GTResults.firstNODESrecordID;
GCTData.timeOfDay = GTResults.firstNodeTime;
dhd = GetConnectionTime(GCT_FLAG_DEADHEADTIME, &GCTData, &distance);
distance = (float)fabs((double)distance);
if(dhd == NO_TIME)
dhd = 0;
TRIPINFOrec.startNODESrecordID = TRIPS.standard.POGNODESrecordID;
TRIPINFOrec.startTime = GTResults.firstNodeTime - dhd;
}
//
// Check pullins
//
if(PARMS.bStandard || TRIPS.standard.PIGNODESrecordID == NO_RECORD)
{
TRIPINFOrec.endNODESrecordID = GTResults.lastNODESrecordID;
TRIPINFOrec.endTime = GTResults.lastNodeTime;
}
else
{
GCTData.fromPATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
GCTData.toPATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
GCTData.fromROUTESrecordID = TRIPS.ROUTESrecordID;
GCTData.fromSERVICESrecordID = TRIPS.SERVICESrecordID;
GCTData.toROUTESrecordID = TRIPS.ROUTESrecordID;
GCTData.toSERVICESrecordID = TRIPS.SERVICESrecordID;
GCTData.fromNODESrecordID = GTResults.lastNODESrecordID;
GCTData.toNODESrecordID = TRIPS.standard.PIGNODESrecordID;
GCTData.timeOfDay = GTResults.lastNodeTime;
dhd = GetConnectionTime(GCT_FLAG_DEADHEADTIME, &GCTData, &distance);
distance = (float)fabs((double)distance);
if(dhd == NO_TIME)
dhd = 0;
TRIPINFOrec.endNODESrecordID = TRIPS.standard.PIGNODESrecordID;
TRIPINFOrec.endTime = GTResults.lastNodeTime + dhd;
}
//
// Figure out the minimum layover
//
if(pTRIPSChunk->layoverMin != NO_TIME)
TRIPINFOrec.layoverMin = pTRIPSChunk->layoverMin;
else
{
minutes = pLayover->minimum.minutes * 60;
percent = (GTResults.lastNodeTime - GTResults.firstNodeTime) * pLayover->minimum.percent / 100;
if(pLayover->minimum.type == 0)
TRIPINFOrec.layoverMin = minutes;
else if(pLayover->minimum.type == 1)
TRIPINFOrec.layoverMin = percent;
else if(pLayover->minimum.type == 2)
TRIPINFOrec.layoverMin =
pLayover->minimum.lower ? min(minutes, percent) : max(minutes, percent);
}
//
// Figure out the maximum layover
//
if(pTRIPSChunk->layoverMax != NO_TIME)
TRIPINFOrec.layoverMax = pTRIPSChunk->layoverMax;
else
{
minutes = pLayover->maximum.minutes * 60;
percent = (GTResults.lastNodeTime - GTResults.firstNodeTime) * pLayover->maximum.percent / 100;
if(pLayover->maximum.type == 0)
TRIPINFOrec.layoverMax = minutes;
else if(pLayover->maximum.type == 1)
TRIPINFOrec.layoverMax = percent;
else if(pLayover->maximum.type == 2)
TRIPINFOrec.layoverMax =
pLayover->maximum.lower ? min(minutes, percent) : max(minutes, percent);
}
//
// And generate the trip arc
//
BLGenerateTripArc( &TRIPINFOrec );
}
}
//
// If m_numConnectionAlerts is non-zero, blow him off
//
if(m_numConnectionAlerts != 0)
{
TMSError(hWndDlg, MB_ICONSTOP, ERROR_173, (HANDLE)NULL);
goto OptimalBlockCleanup;
}
//
// Generate the wait arcs between the trips
//
StatusBarText("Generating wait arcs...");
StatusBar(-1L, -1L);
BLGenerateWaitArcs(FALSE);
//
// Generate deadhead and equivalence data into DEADHEADINFO
//
rcode2 = btrieve(B_GETFIRST, TMS_CONNECTIONS, &CONNECTIONS, &CONNECTIONSKey0, 0);
numDeadheadsForBlocker = 0;
while(rcode2 == 0)
{
if(StatusBarAbort())
goto OptimalBlockCleanup;
if(PARMS.bDeadheading)
{
if((CONNECTIONS.flags & CONNECTIONS_FLAG_DEADHEADTIME) &&
(PARMS.bDeadheadAll || CONNECTIONS.connectionTime <= PARMS.maxDeadheadTime))
{
DEADHEADINFODef DEADHEADINFOrec;
DEADHEADINFOrec.fromTimeOfDay = CONNECTIONS.fromTimeOfDay;
DEADHEADINFOrec.toTimeOfDay = CONNECTIONS.toTimeOfDay;
DEADHEADINFOrec.fromNODESrecordID = CONNECTIONS.fromNODESrecordID;
DEADHEADINFOrec.toNODESrecordID = CONNECTIONS.toNODESrecordID;
DEADHEADINFOrec.flags = CONNECTIONS.flags;
DEADHEADINFOrec.deadheadTime = CONNECTIONS.connectionTime;
BLGenerateDeadheadArcs( &DEADHEADINFOrec );
numDeadheadsForBlocker++;
}
}
if(CONNECTIONS.flags & CONNECTIONS_FLAG_EQUIVALENT)
{
DEADHEADINFODef DEADHEADINFOrec;
DEADHEADINFOrec.fromTimeOfDay = CONNECTIONS.fromTimeOfDay;
DEADHEADINFOrec.toTimeOfDay = CONNECTIONS.toTimeOfDay;
DEADHEADINFOrec.fromNODESrecordID = CONNECTIONS.fromNODESrecordID;
DEADHEADINFOrec.toNODESrecordID = CONNECTIONS.toNODESrecordID;
DEADHEADINFOrec.flags = CONNECTIONS.flags;
DEADHEADINFOrec.deadheadTime = 0;
BLGenerateDeadheadArcs( &DEADHEADINFOrec );
numDeadheadsForBlocker++;
}
rcode2 = btrieve(B_GETNEXT, TMS_CONNECTIONS, &CONNECTIONS, &CONNECTIONSKey0, 0);
}
if(StatusBarAbort())
goto OptimalBlockCleanup;
//
// Get the minimum and maximum number of vehicles parameters.
// This only applies to Optimal, so it's done here rather than above.
//
if(SendMessage(hCtlMIN, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
maxVehicles = NO_TIME;
SendMessage(hCtlMINVEHICLES, WM_GETTEXT,
(WPARAM)TEMPSTRING_LENGTH, (LONG)(LPSTR)tempString);
if(strcmp(tempString, "") == 0)
minVehicles = NO_TIME;
else
minVehicles = atol(tempString);
}
else
{
minVehicles = NO_TIME;
SendMessage(hCtlMAXVEHICLES, WM_GETTEXT,
(WPARAM)TEMPSTRING_LENGTH, (LONG)(LPSTR)tempString);
if(strcmp(tempString, "") == 0)
maxVehicles = NO_TIME;
else
maxVehicles = atol(tempString);
}
//
// Call the blocker
//
m_pBLOCKSDATA = (BLOCKSDATADef *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BLOCKSDATADef) * m_numTripsForBlocker);
if(m_pBLOCKSDATA == NULL)
{
AllocationError(__FILE__, __LINE__, FALSE);
goto OptimalBlockCleanup;
}
StatusBarText("Optimal blocking in progress...");
sblock(minVehicles, maxVehicles);
if(StatusBarAbort())
{
goto OptimalBlockCleanup;
}
//
// Update the file with the results
//
lastBlock = GetNewBlockNumber(pDI);
StatusBarText("Blocking complete - writing results...");
StatusBarEnableCancel(FALSE);
for(nJ = 0; nJ < numTrips; nJ++)
{
StatusBar((long)nJ, (long)numTrips);
TRIPSKey0.recordID = m_pBLOCKSDATA[nJ].TRIPSrecordID;
if((rcode2 = btrieve(B_GETEQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey0, 0)) != 0)
{
MessageBeep(MB_ICONSTOP);
LoadString(hInst, ERROR_015, szarString, sizeof(szarString));
SetFocus(hCtlFROMROUTE);
MessageBox(hWndDlg, szarString, TMS, MB_ICONSTOP);
goto OptimalBlockCleanup;
}
GenerateTrip(TRIPS.ROUTESrecordID, TRIPS.SERVICESrecordID,
TRIPS.directionIndex, TRIPS.PATTERNNAMESrecordID,
TRIPS.timeAtMLP, GENERATETRIP_FLAG_DISPLAYERRORS, >Results);
pTRIPSChunk->blockNumber = m_pBLOCKSDATA[nJ].blockNumber + lastBlock;
pTRIPSChunk->RGRPROUTESrecordID = pDI->fileInfo.routeRecordID;
pTRIPSChunk->SGRPSERVICESrecordID = pDI->fileInfo.serviceRecordID;
pTRIPSChunk->blockSequence = GTResults.firstNodeTime;
btrieve(B_UPDATE, TMS_TRIPS, &TRIPS, &TRIPSKey0, 0);
}
OptimalBlockCleanup:
BLCleanup();
TMSHeapFree(m_pBLOCKSDATA);
TMSHeapFree(pTRIPSrecordIDs);
m_numTripsForBlocker = 0;
StatusBarEnd();
} // blockingType
EndDialog(hWndDlg, TRUE);
break;
}
break; // End of WM_COMMAND
default:
return FALSE;
}
return TRUE;
} // End of ADDBLOCKMsgProc
/*
* Initialize the aurp pipe -
* -Create, initialize, and start the aurpd kernel process; we need
* a process to permit queueing between the socket and the stream,
* which is necessary for orderly access to the socket structure.
* -The user process (aurpd) is there to 'build' the AURP
* stream, act as a 'logging agent' (:-}), and hold open the stream
* during its use.
* -Data and AURP packets from the DDP stream will be fed into the
* UDP tunnel (AURPsend())
* -Data and AURP packets from the UDP tunnel will be fed into the
* DDP stream (ip_to_atalk(), via the kernel process).
*/
int
aurpd_start()
{
register int error;
register struct socket *so;
struct mbuf *m;
int maxbuf;
struct sockopt sopt;
if (suser(current_proc()->p_ucred, ¤t_proc()->p_acflag) != 0 )
return(EPERM);
/*
* Set up state prior to starting kernel process so we can back out
* (error return) if something goes wrong.
*/
bzero((char *)&aurp_global.tunnel, sizeof(aurp_global.tunnel));
/*lock_alloc(&aurp_global.glock, LOCK_ALLOC_PIN, AURP_EVNT_LOCK, -1);*/
ATLOCKINIT(aurp_global.glock);
ATEVENTINIT(aurp_global.event_anchor);
/* open udp socket */
if (aurp_global.udp_port == 0)
aurp_global.udp_port = AURP_SOCKNUM;
error = socreate(AF_INET, &aurp_global.tunnel, SOCK_DGRAM,
IPPROTO_UDP);
if (error)
{ dPrintf(D_M_AURP, D_L_FATAL, ("AURP: Can't get socket (%d)\n",
error));
return(error);
}
so = aurp_global.tunnel;
if ((error = aurp_bindrp(so)) != 0)
{ dPrintf(D_M_AURP, D_L_FATAL,
("AURP: Can't bind to port %d (error %d)\n",
aurp_global.udp_port, error));
soclose(so);
return(error);
}
sblock(&so->so_rcv, M_WAIT);
sblock(&so->so_snd, M_WAIT);
/*
* Set socket Receive buffer size
*/
m = m_get(M_WAIT, MT_SOOPTS);
if (m == NULL) {
error = ENOBUFS;
goto out;
} else {
maxbuf = M_RCVBUF;
sopt.sopt_val = &maxbuf;
sopt.sopt_valsize = sizeof(maxbuf);
sopt.sopt_level = SOL_SOCKET;
sopt.sopt_name = SO_RCVBUF;
sopt.sopt_dir = SOPT_SET;
sopt.sopt_p = NULL;
if ((error = sosetopt(so, &sopt)) != 0)
goto out;
}
/*
* Set socket Send buffer size
*/
m = m_get(M_WAIT, MT_SOOPTS);
if (m == NULL) {
error = ENOBUFS;
goto out;
} else {
maxbuf = M_SNDBUF;
sopt.sopt_val = &maxbuf;
sopt.sopt_valsize = sizeof(maxbuf);
sopt.sopt_level = SOL_SOCKET;
sopt.sopt_name = SO_SNDBUF;
sopt.sopt_dir = SOPT_SET;
sopt.sopt_p = NULL;
if ((error = sosetopt(so, &sopt)) != 0)
goto out;
}
so->so_upcall = aurp_wakeup;
so->so_upcallarg = (caddr_t)AE_UDPIP; /* Yuck */
so->so_state |= SS_NBIO;
so->so_rcv.sb_flags |=(SB_SEL|SB_NOINTR);
so->so_snd.sb_flags |=(SB_SEL|SB_NOINTR);
out:
sbunlock(&so->so_snd);
sbunlock(&so->so_rcv);
return(error);
}
