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); }