int do_prod_lost( BUFF_HDR *buff_hdr, ACQ_TABLE *acq_tbl)
{
long prod_errors;
if(acq_tbl->proc_base_prod_seqno_last == 0){
prod_errors = 0;
}else{
prod_errors = (buff_hdr->proc_prod_seqno - (acq_tbl->proc_base_prod_seqno_last + 1));
}
if(prod_errors <= 0){
prod_errors = 0;
}else{
/* Now generate retransmission request */
generate_retrans_rqst(acq_tbl,(acq_tbl->proc_base_prod_seqno_last + 1),
(buff_hdr->proc_prod_seqno-1),
RETRANS_RQST_CAUSE_RCV_ERR);
}
acq_tbl->proc_tot_prods_lost_errs += prod_errors;
/* Need to log prod_errors */
if(acq_tbl->proc_base_prod_seqno_last == 0){
uinfo("LOST=%ld total(%ld) %s prod(%ld) prod_seqno was RESET to 0 \n",
prod_errors,acq_tbl->proc_tot_prods_lost_errs,
GET_PROD_TYPE_NAME(buff_hdr->proc_prod_type),buff_hdr->proc_prod_seqno);
}else{
uinfo("LOST=%ld total(%ld) %s prod(%ld) expect prod(%ld)\n",
prod_errors, acq_tbl->proc_tot_prods_lost_errs,
GET_PROD_TYPE_NAME(buff_hdr->proc_prod_type),buff_hdr->proc_prod_seqno,
acq_tbl->proc_base_prod_seqno_last + 1);
}
return (0);
}
static int tweak_set_configuration_cmd(struct urb *urb)
{
struct usb_ctrlrequest *req;
__u16 config;
req = (struct usb_ctrlrequest *) urb->setup_packet;
config = le16_to_cpu(req->wValue);
/*
* I have never seen a multi-config device. Very rare.
* For most devices, this will be called to choose a default
* configuration only once in an initialization phase.
*
* set_configuration may change a device configuration and its device
* drivers will be unbound and assigned for a new device configuration.
* This means this usbip driver will be also unbound when called, then
* eventually reassigned to the device as far as driver matching
* condition is kept.
*
* Unfortunatelly, an existing usbip connection will be dropped
* due to this driver unbinding. So, skip here.
* A user may need to set a special configuration value before
* exporting the device.
*/
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
uinfo("set_configuration (%d) to %s\n", config, urb->dev->dev.bus_id);
#else
uinfo("set_configuration (%d) to %s\n", config, dev_name(&urb->dev->dev));
#endif
uinfo("but, skip!\n");
return 0;
//return usb_driver_set_configuration(urb->dev, config);
}
static int tweak_clear_halt_cmd(struct urb *urb)
{
struct usb_ctrlrequest *req;
int target_endp;
int target_dir;
int target_pipe;
int ret;
req = (struct usb_ctrlrequest *) urb->setup_packet;
/*
* The stalled endpoint is specified in the wIndex value. The endpoint
* of the urb is the target of this clear_halt request (i.e., control
* endpoint).
*/
target_endp = le16_to_cpu(req->wIndex) & 0x000f;
/* the stalled endpoint direction is IN or OUT?. USB_DIR_IN is 0x80. */
target_dir = le16_to_cpu(req->wIndex) & 0x0080;
if (target_dir)
target_pipe = usb_rcvctrlpipe(urb->dev, target_endp);
else
target_pipe = usb_sndctrlpipe(urb->dev, target_endp);
ret = usb_clear_halt(urb->dev, target_pipe);
if (ret < 0)
uinfo("clear_halt error: devnum %d endp %d, %d\n",
urb->dev->devnum, target_endp, ret);
else
uinfo("clear_halt done: devnum %d endp %d\n",
urb->dev->devnum, target_endp);
return ret;
}
static int usbhost_waiter(struct usbhost_connection_s *dev)
#endif
{
struct usbhost_hubport_s *hport;
uinfo("Running\n");
for (;;)
{
/* Wait for the device to change state */
DEBUGVERIFY(CONN_WAIT(dev, &hport));
uinfo("%s\n", hport->connected ? "connected" : "disconnected");
/* Did we just become connected? */
if (hport->connected)
{
/* Yes.. enumerate the newly connected device */
(void)CONN_ENUMERATE(dev, hport);
}
}
/* Keep the compiler from complaining */
return 0;
}
int stm32_usbhost_initialize(void)
{
int pid;
int ret;
/* First, register all of the class drivers needed to support the drivers
* that we care about:
*/
uinfo("Register class drivers\n");
#ifdef CONFIG_USBHOST_MSC
/* Register the USB mass storage class class */
ret = usbhost_msc_initialize();
if (ret != OK)
{
uerr("ERROR: Failed to register the mass storage class: %d\n", ret);
}
#endif
#ifdef CONFIG_USBHOST_CDCACM
/* Register the CDC/ACM serial class */
ret = usbhost_cdcacm_initialize();
if (ret != OK)
{
uerr("ERROR: Failed to register the CDC/ACM serial class: %d\n", ret);
}
#endif
/* Then get an instance of the USB host interface */
uinfo("Initialize USB host\n");
g_usbconn = stm32_otgfshost_initialize(0);
if (g_usbconn)
{
/* Start a thread to handle device connection. */
uinfo("Start usbhost_waiter\n");
pid = task_create("usbhost", CONFIG_USBHOST_DEFPRIO,
CONFIG_USBHOST_STACKSIZE,
(main_t)usbhost_waiter, (FAR char * const *)NULL);
return pid < 0 ? -ENOEXEC : OK;
}
return -ENODEV;
}
void stm32_usbinitialize(void)
{
uinfo("called\n");
/* USB Soft Connect Pullup */
stm32_configgpio(GPIO_USB_PULLUP);
}
QString PreviewGenerator::CreateAccessibleFilename(
const QString &pathname, const QString &outFileName)
{
QString outname = pathname + ".png";
if (outFileName.isEmpty())
return QDeepCopy<QString>(outname);
outname = outFileName;
QFileInfo fi(outname);
if (outname == fi.fileName())
{
QString dir = QString::null;
if (pathname.contains(":"))
{
QUrl uinfo(pathname);
uinfo.setPath("");
dir = uinfo.toString();
}
else
{
dir = QFileInfo(pathname).dirPath();
}
outname = dir + "/" + fi.fileName();
VERBOSE(VB_IMPORTANT, LOC + QString("outfile '%1' -> '%2'")
.arg(outFileName).arg(outname));
}
return QDeepCopy<QString>(outname);
}
int log_prod_lost(long in_prod_errors, long in_tot_prods_lost_errs, long in_prod_seqno)
{
static char FNAME[]="log_prod_lost";
char prod_log_buff[256]; /* prod log buffer */
time_t now_time; /* now time */
struct tm *tmtime; /* time */
/* "STATUS LOST %ld product(s) total(%ld) before prod(%ld)", */
sprintf(prod_log_buff, "STATUS LOST %ld product(s) before prod(%ld) total(%ld)",
in_prod_errors,
in_prod_seqno,
in_tot_prods_lost_errs);
time(&now_time);
tmtime = (struct tm *)gmtime(&now_time); /* time */
sprintf(prod_log_buff, "%s %s", prod_log_buff,
get_date_time(tmtime, global_time_zone));
uinfo("%s %s \n",get_date_time(tmtime, global_time_zone),prod_log_buff);
return(0);
}
static int ehci_waiter(int argc, char *argv[])
{
FAR struct usbhost_hubport_s *hport;
uinfo("ehci_waiter: Running\n");
for (;;)
{
/* Wait for the device to change state */
DEBUGVERIFY(CONN_WAIT(g_ehciconn, &hport));
syslog(LOG_INFO, "ehci_waiter: %s\n",
hport->connected ? "connected" : "disconnected");
/* Did we just become connected? */
if (hport->connected)
{
/* Yes.. enumerate the newly connected device */
(void)CONN_ENUMERATE(g_ehciconn, hport);
}
}
/* Keep the compiler from complaining */
return 0;
}
static int tweak_reset_device_cmd(struct urb *urb)
{
struct usb_ctrlrequest *req;
__u16 value;
__u16 index;
int ret;
req = (struct usb_ctrlrequest *) urb->setup_packet;
value = le16_to_cpu(req->wValue);
index = le16_to_cpu(req->wIndex);
#if 0 /* hided by tf, for reason that "bus_id" isn't supported in kernel2.6.31 */
uinfo("reset_device (port %d) to %s\n", index, urb->dev->dev.bus_id);
#endif
/* all interfaces should be owned by usbip driver, so just reset it. */
ret = usb_lock_device_for_reset(urb->dev, NULL);
if (ret < 0) {
uerr("lock for reset\n");
return ret;
}
#if 0 /* hided it temporarily */
/* try to reset the device */
ret = usb_reset_composite_device(urb->dev, NULL);
if (ret < 0)
uerr("device reset\n");
#endif
usb_unlock_device(urb->dev);
return ret;
}
QString PreviewGenerator::CreateAccessibleFilename(
const QString &pathname, const QString &outFileName)
{
QString outname = pathname + ".png";
if (outFileName.isEmpty())
return outname;
outname = outFileName;
QFileInfo fi(outname);
if (outname == fi.fileName())
{
QString dir = QString::null;
if (pathname.contains(':'))
{
QUrl uinfo(pathname);
uinfo.setPath("");
dir = uinfo.toString();
}
else
{
dir = QFileInfo(pathname).path();
}
outname = dir + "/" + fi.fileName();
LOG(VB_FILE, LOG_INFO, LOC + QString("outfile '%1' -> '%2'")
.arg(outFileName).arg(outname));
}
return outname;
}
static int tweak_reset_device_cmd(struct urb *urb)
{
struct usb_ctrlrequest *req;
__u16 value;
__u16 index;
int ret;
req = (struct usb_ctrlrequest *) urb->setup_packet;
value = le16_to_cpu(req->wValue);
index = le16_to_cpu(req->wIndex);
uinfo("reset_device (port %d) to %s\n", index, urb->dev->dev.bus->name);
/* all interfaces should be owned by usbip driver, so just reset it. */
ret = usb_lock_device_for_reset(urb->dev, NULL);
if (ret < 0) {
uerr("lock for reset\n");
return ret;
}
/* try to reset the device */
ret = usb_reset_device(urb->dev);
if (ret < 0)
uerr("device reset\n");
usb_unlock_device(urb->dev);
return ret;
}
static int board_mscclassobject(int minor,
FAR struct usbdev_devinfo_s *devinfo,
FAR struct usbdevclass_driver_s **classdev)
{
int ret;
DEBUGASSERT(g_mschandle == NULL);
/* Configure the mass storage device */
uinfo("Configuring with NLUNS=1\n");
ret = usbmsc_configure(1, &g_mschandle);
if (ret < 0)
{
uerr("ERROR: usbmsc_configure failed: %d\n", -ret);
return ret;
}
uinfo("MSC handle=%p\n", g_mschandle);
/* Bind the LUN(s) */
uinfo("Bind LUN=0 to /dev/mmcsd0\n");
ret = usbmsc_bindlun(g_mschandle, "/dev/mmcsd0", 0, 0, 0, false);
if (ret < 0)
{
uerr("ERROR: usbmsc_bindlun failed for LUN 1 at /dev/mmcsd0: %d\n",
ret);
usbmsc_uninitialize(g_mschandle);
g_mschandle = NULL;
return ret;
}
/* Get the mass storage device's class object */
ret = usbmsc_classobject(g_mschandle, devinfo, classdev);
if (ret < 0)
{
uerr("ERROR: usbmsc_classobject failed: %d\n", -ret);
usbmsc_uninitialize(g_mschandle);
g_mschandle = NULL;
}
return ret;
}
/*
* The RPC dispatch routine for this program.
* Registered as a callback by svc_register() below.
* Note that only NULLPROC and NOTIFICATION rpc procs are
* handled by this program.
*/
static void
notifymeprog_5(struct svc_req *rqstp, SVCXPRT *transp)
{
prod_info notice;
switch (rqstp->rq_proc) {
case NULLPROC:
svc_sendreply(transp, (xdrproc_t)xdr_void, (caddr_t)NULL);
return;
case NOTIFICATION:
(void) memset((char*)¬ice, 0, sizeof(notice));
if (!svc_getargs(transp, (xdrproc_t)xdr_prod_info,
(caddr_t)¬ice))
{
svcerr_decode(transp);
return;
}
(void)exitIfDone(0);
/*
* Update the request filter with the timestamp
* we just recieved.
* N.B.: There can still be duplicates after
* a reconnect.
*/
clss.from = notice.arrival;
timestamp_incr(&clss.from);
/*
* your code here, example just logs it
*/
uinfo("%s", s_prod_info(NULL, 0, ¬ice, ulogIsDebug()));
if(!svc_sendreply(transp, (xdrproc_t)xdr_ldm_replyt,
(caddr_t) &reply))
{
svcerr_systemerr(transp);
}
(void)exitIfDone(0);
if(!svc_freeargs(transp, xdr_prod_info, (caddr_t) ¬ice)) {
uerror("unable to free arguments");
exit(1);
}
default:
svcerr_noproc(transp);
return;
}
}
/*
* Send a product from file-descriptor to clnt using LDM-5 protocol.
*/
static void
send_product_5(CLIENT *clnt, int fd, prod_info *infop)
{
static ldm_replyt reply;
enum clnt_stat rpc_stat;
datapkt pkt;
ssize_t unsent;
ssize_t nread;
char buf[DBUFMAX];
rpc_stat = my_comingsoon_5(clnt, infop, DBUFMAX, &reply);
if(rpc_stat != RPC_SUCCESS)
{
uerror("send_product_5: %s %s",
infop->ident,
clnt_sperrno(rpc_stat));
return;
}
/* else */
if(reply.code != OK)
{
if(reply.code == DONT_SEND)
uinfo("send_product_5: %s: %s",
infop->ident,
s_ldm_errt(reply.code));
else
uerror("send_product_5: %s: %s",
infop->ident,
s_ldm_errt(reply.code));
return;
}
pkt.signaturep = &infop->signature;
pkt.pktnum = 0;
for(unsent = (ssize_t)infop->sz; unsent > 0;
unsent -= nread )
{
nread = read(fd, buf, DBUFMAX);
if(nread <= 0)
{
serror("read: %s (seqno %d)",
infop->ident, infop->seqno);
break;
} /* else */
pkt.data.dbuf_len = (u_int)nread;
pkt.data.dbuf_val = buf;
rpc_stat = my_blkdata_5(clnt, &pkt, &reply);
if(rpc_stat != RPC_SUCCESS)
break;
if(reply.code != OK)
break;
pkt.pktnum++;
}
}
DWORD WINAPI EM_UserLogin::Proc_UDP_Recv(LPVOID lParam)
{
//CEIM02Dlg* pDlg = ((CEIM02Dlg*)AfxGetMainWnd());
CEIM02Dlg *pDlg = (CEIM02Dlg*)AfxGetApp()->m_pMainWnd;
SOCKET s = socket(AF_INET, SOCK_DGRAM, 0);
if (s == INVALID_SOCKET)
{
::MessageBox(NULL, _T("Socket creating error."), _T("接受线程错误"), MB_OK);
return -1;
}
SOCKADDR_IN sin;
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_family = AF_INET;
sin.sin_port = htons(UDP_RECV_MSG_PORT);
if (bind(s, (PSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)
{
::MessageBox(NULL, _T("Socket binding error."), _T("接受线程错误"), MB_OK);
}
SOCKADDR_IN client;
int sinLen;
int ret;
char buf[8192];
char ip[128];
while(1)
{
sinLen = sizeof(SOCKADDR_IN);
if ((ret = recvfrom(s, buf, 8192, 0, (PSOCKADDR)&client, &sinLen)) == SOCKET_ERROR)
{
::MessageBox(0,"UDP recvfrom failed.", "Alert", MB_OK);
break;
}
EM_DATA data(buf, ret);
if (data.msg == EM_USERLOGIN || data.msg == EM_USERLOGOUT)
{
strcpy(ip, inet_ntoa(client.sin_addr));
char name[256];
char hostName[256];
char groupName[128];
EM_UserInfo *ui = ((EM_UserInfo*)data.buf);
ui->GetDisplayName(name);
ui->GetHostName(hostName);
ui->GetGroupName(groupName);
// Add to tree ---------------------------------------------------
EM_USERINFO uinfo(strupr(hostName), ip, groupName);
pDlg->_User_AddNewUser(name, uinfo);
// ===============================================================
}
}
return 0;
}
/*ARGSUSED*/
static int
addtostats(const prod_info *infop, const void *datap,
void *xprod, size_t size, void *notused)
{
struct timeval tv;
pq_ctimestamp(pq, &tv);
if(tvIsNone(tv))
tv = TS_ZERO;
if(ulogIsVerbose())
uinfo("%s", s_prod_info(NULL, 0, infop, ulogIsDebug()));
binstats(infop, &tv);
return 0;
}
static int tweak_set_interface_cmd(struct urb *urb)
{
struct usb_ctrlrequest *req;
__u16 alternate;
__u16 interface;
int ret;
req = (struct usb_ctrlrequest *) urb->setup_packet;
alternate = le16_to_cpu(req->wValue);
interface = le16_to_cpu(req->wIndex);
dbg_stub_rx("set_interface: inf %u alt %u\n", interface, alternate);
ret = usb_set_interface(urb->dev, interface, alternate);
if (ret < 0)
uinfo("set_interface error: inf %u alt %u, %d\n",
interface, alternate, ret);
else
uinfo("set_interface done: inf %u alt %u\n", interface, alternate);
return ret;
}
static int tweak_reset_device_cmd(struct urb *urb)
{
struct usb_ctrlrequest *req;
__u16 value;
__u16 index;
int ret;
req = (struct usb_ctrlrequest *) urb->setup_packet;
value = le16_to_cpu(req->wValue);
index = le16_to_cpu(req->wIndex);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
uinfo("reset_device (port %d) to %s\n", index, urb->dev->dev.bus_id);
#else
uinfo("reset_device (port %d) to %s\n", index, dev_name(&urb->dev->dev));
#endif
/* all interfaces should be owned by usbip driver, so just reset it. */
ret = usb_lock_device_for_reset(urb->dev, NULL);
if (ret < 0) {
uerr("lock for reset\n");
return ret;
}
/* try to reset the device */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
ret = usb_reset_composite_device(urb->dev, NULL);
#else
ret = usb_reset_device(urb->dev);
#endif
if (ret < 0)
uerr("device reset\n");
usb_unlock_device(urb->dev);
return ret;
}
int prod_retrans_abort_entry (ACQ_TABLE *p_acqtable, long prod_seqno, int err_cause)
{
static char FNAME[]="retrans_abort_entry";
int index_value; /* index for prod_seqno */
int retrans_table_typ; /* retrans table type */
PROD_RETRANS_ENTRY *p_retrans_entry;
PROD_RETRANS_ENTRY_INFO *p_retrans_entry_info;
if(prod_retrans_get_addr(p_acqtable->proc_base_channel_type_last, p_prod_retrans_table,
&p_retrans_entry_info, &p_retrans_entry, &retrans_table_typ) < 0){
uerror("%s ignore abort \n",FNAME);
return(ERROR);
}
/* Now get the index value */
index_value = prod_seqno %
p_retrans_entry_info->numb_entries;
if(index_value < 0) {
index_value = -index_value;
}
if(index_value >= p_retrans_entry_info->numb_entries) {
index_value = 0;
}
if(ulogIsVerbose ()){
uinfo("%s ok abort %s tbl[%d]=%ld\n",FNAME,
GET_SBN_TYP_NAME(p_acqtable->proc_base_channel_type_last),
index_value,
p_retrans_entry[index_value].prod_seqno);
}
prod_retrans_update_entry(p_acqtable, (BUFF_HDR *)NULL,
p_retrans_entry_info,
&p_retrans_entry[index_value],
index_value,
prod_seqno,
p_acqtable->proc_prod_run_id,
RETRANS_ENTRY_FLAG_AVAIL, err_cause);
return(0);
}
static void* usbhost_detect(void *arg)
{
(void)arg;
struct usbhost_hubport_s *hport;
uinfo("INFO: Starting usb detect thread\n");
for (;;)
{
CONN_WAIT(g_usbconn, &hport);
if (hport->connected)
{
CONN_ENUMERATE(g_usbconn, hport);
}
}
return 0;
}
static int
split_prod(const prod_info *infop, const void *datap,
void *xprod, size_t size, void *vp)
{
size_t *nsp = (size_t *)vp;
int ns;
if(ulogIsVerbose())
uinfo("%s", s_prod_info(NULL, 0, infop, ulogIsDebug()));
ns = surf_split(infop, datap, doOne);
nprods++;
(void)kill(SIGCONT, act_pid);
if(nsp != NULL && ns >= 0)
*nsp = (size_t)ns;
return 0;
}
void lpc31_usbhost_vbusdrive(int rhport, bool enable)
{
uinfo("RHPort%d: enable=%d\n", rhport+1, enable);
/* The LPC3131 has only a single root hub port */
if (rhport == 0)
{
/* Then enable or disable VBUS power */
if (enable)
{
/* Enable the Power Switch by driving the enable pin low */
#warning Missing logic
}
else
{
/* Disable the Power Switch by driving the enable pin high */
#warning Missing logic
}
}
}
void lpc31_usbhost_vbusdrive(int rhport, bool enable)
{
uinfo("RHPort%d: enable=%d\n", rhport+1, enable);
/* The LPC3131 has only a single root hub port */
if (rhport == 0)
{
/* Then enable or disable VBUS power */
if (enable)
{
/* Enable the Power Switch by driving the enable pin low */
gpio_outputlow(LPC31_IOCONFIG_GPIO, GPIO_NOTG_PWR_E);
}
else
{
/* Disable the Power Switch by driving the enable pin high */
gpio_outputhigh(LPC31_IOCONFIG_GPIO, GPIO_NOTG_PWR_E);
}
}
}
static int
doOne(const prod_info *infop, const void *datap)
{
struct product prod;
int status = ENOERR;
if(ulogIsDebug())
udebug("%s", s_prod_info(NULL, 0, infop, 1));
prod.info = *infop;
prod.data = (void *)datap; /* cast away const */
nsplit++; /* ?? Do it here on only on success ?? */
status = pq_insertNoSig(opq, &prod);
if(status == ENOERR)
{
return status; /* Normal return */
}
/* else */
if(status == PQUEUE_DUP)
{
ndups++;
if(ulogIsVerbose())
uinfo("Product already in queue: %s",
s_prod_info(NULL, 0, &prod.info,
ulogIsDebug()));
return status;
}
/* else, error */
uerror("pq_insert: %s\n", strerror(status));
return status;
}
/*
* Handles an incoming RPC connection on a socket. This method will fork(2)
* a copy of this program, if appropriate, for handling incoming RPC messages.
*
* sock The socket with the incoming RPC connection.
*/
static void handle_connection(
int sock)
{
struct sockaddr_in raddr;
socklen_t len;
int xp_sock;
pid_t pid;
SVCXPRT *xprt;
int status = 1; /* EXIT_FAILURE assumed unless one_svc_run() success */
peer_info* remote = get_remote();
again: len = sizeof(raddr);
(void) memset(&raddr, 0, len);
xp_sock = accept(sock, (struct sockaddr *) &raddr, &len);
(void) exitIfDone(0);
if (xp_sock < 0) {
if (errno == EINTR) {
errno = 0;
goto again;
}
/* else */
serror("accept");
return;
}
/*
* Don't bother continuing if no more clients are allowed.
*/
if (cps_count() >= maxClients) {
setremote(&raddr, xp_sock);
unotice("Denying connection from [%s] because too many clients",
remote->astr);
(void) close(xp_sock);
return;
}
pid = ldmfork();
if (pid == -1) {
log_add("Couldn't fork process to handle incoming connection");
log_log(LOG_ERR);
/* TODO: try again?*/
(void) close(xp_sock);
return;
}
if (pid > 0) {
/* parent */
/* unotice("child %d", pid); */
(void) close(xp_sock);
if (cps_add(pid))
serror("Couldn't add child PID to set");
return;
}
/* else child */
setremote(&raddr, xp_sock);
/* Access control */
if (!lcf_isHostOk(remote)) {
ensureRemoteName(&raddr);
if (!lcf_isHostOk(remote)) {
if (remote->printname == remote->astr) {
unotice("Denying connection from [%s] because not "
"allowed", remote->astr);
}
else {
unotice("Denying connection from \"%s\" because not "
"allowed", remote_name());
}
/*
* Try to tell the other guy.
* TODO: Why doesn't this work?
*/
xprt = svcfd_create(xp_sock, remote->sendsz, remote->recvsz);
if (xprt != NULL ) {
xprt->xp_raddr = raddr;
xprt->xp_addrlen = (int) len;
svcerr_weakauth(xprt);
svc_destroy(xprt);
}
goto unwind_sock;
}
}
/* else */
endpriv();
portIsMapped = 0; /* don't call pmap_unset() from child */
(void) close(sock);
/* Set the ulog identifier, optional. */
set_abbr_ident(remote_name(), NULL );
uinfo("Connection from %s", remote_name());
xprt = svcfd_create(xp_sock, remote->sendsz, remote->recvsz);
if (xprt == NULL ) {
uerror("Can't create fd service.");
goto unwind_sock;
}
/* hook up the remote address to the xprt. */
/* xprt->xp_raddr = raddr; */
xprt->xp_raddr = raddr;
xprt->xp_addrlen = (int) len;
if (!svc_register(xprt, LDMPROG, 4, ldmprog_4, 0)) {
uerror("unable to register LDM-4 service.");
svc_destroy(xprt);
goto unwind_sock;
}
if (!svc_register(xprt, LDMPROG, FIVE, ldmprog_5, 0)) {
uerror("unable to register LDM-5 service.");
svc_destroy(xprt);
goto unwind_sock;
}
if (!svc_register(xprt, LDMPROG, SIX, ldmprog_6, 0)) {
uerror("unable to register LDM-6 service.");
svc_destroy(xprt);
goto unwind_sock;
}
#if WANT_MULTICAST
if (!svc_register(xprt, LDMPROG, SEVEN, ldmprog_7, 0)) {
uerror("unable to register LDM-7 service.");
svc_destroy(xprt);
goto unwind_sock;
}
#endif
/*
* handle rpc requests
*/
{
const unsigned TIMEOUT = 2*interval;
status = one_svc_run(xp_sock, TIMEOUT);
(void) exitIfDone(0);
if (status == 0) {
log_add("Done");
log_log(LOG_INFO);
}
else if (status == ETIMEDOUT) {
log_add("Connection from client LDM silent for %u seconds",
TIMEOUT);
log_log(LOG_NOTICE);
}
else { /* connection to client lost */
log_add("Connection with client LDM closed");
log_log(LOG_INFO);
status = 0; /* EXIT_SUCCESS */
}
}
/* svc_destroy(xprt); done by svc_getreqset() */
unwind_sock: (void) close(xp_sock);
exit(status);
}
static int composite_setup(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev,
FAR const struct usb_ctrlreq_s *ctrl,
FAR uint8_t *dataout, size_t outlen)
{
FAR struct composite_dev_s *priv;
FAR struct usbdev_req_s *ctrlreq;
uint16_t value;
uint16_t index;
uint16_t len;
bool dispatched = false;
int ret = -EOPNOTSUPP;
#ifdef CONFIG_DEBUG_FEATURES
if (!driver || !dev || !dev->ep0 || !ctrl)
{
usbtrace(TRACE_CLSERROR(USBCOMPOSITE_TRACEERR_SETUPINVALIDARGS), 0);
return -EIO;
}
#endif
/* Extract a reference to private data */
usbtrace(TRACE_CLASSSETUP, ctrl->req);
priv = ((FAR struct composite_driver_s *)driver)->dev;
#ifdef CONFIG_DEBUG_FEATURES
if (!priv)
{
usbtrace(TRACE_CLSERROR(USBCOMPOSITE_TRACEERR_EP0NOTBOUND2), 0);
return -ENODEV;
}
#endif
ctrlreq = priv->ctrlreq;
/* Extract the little-endian 16-bit values to host order */
value = GETUINT16(ctrl->value);
index = GETUINT16(ctrl->index);
len = GETUINT16(ctrl->len);
uinfo("type=%02x req=%02x value=%04x index=%04x len=%04x\n",
ctrl->type, ctrl->req, value, index, len);
UNUSED(index);
if ((ctrl->type & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_STANDARD)
{
/**********************************************************************
* Standard Requests
**********************************************************************/
switch (ctrl->req)
{
case USB_REQ_GETDESCRIPTOR:
{
/* The value field specifies the descriptor type in the MS byte and the
* descriptor index in the LS byte (order is little endian)
*/
switch (ctrl->value[1])
{
case USB_DESC_TYPE_DEVICE:
{
ret = USB_SIZEOF_DEVDESC;
memcpy(ctrlreq->buf, composite_getdevdesc(), ret);
}
break;
#ifdef CONFIG_USBDEV_DUALSPEED
case USB_DESC_TYPE_DEVICEQUALIFIER:
{
ret = USB_SIZEOF_QUALDESC;
memcpy(ctrlreq->buf, composite_getqualdesc(), ret);
}
break;
case USB_DESC_TYPE_OTHERSPEEDCONFIG:
#endif
case USB_DESC_TYPE_CONFIG:
{
#ifdef CONFIG_USBDEV_DUALSPEED
ret = composite_mkcfgdesc(ctrlreq->buf, dev->speed,
ctrl->value[1]);
#else
ret = composite_mkcfgdesc(ctrlreq->buf);
#endif
}
break;
case USB_DESC_TYPE_STRING:
{
/* value == string index. Zero is the language ID. */
uint8_t strid = ctrl->value[0];
FAR struct usb_strdesc_s *buf = (FAR struct usb_strdesc_s *)ctrlreq->buf;
if (strid <= COMPOSITE_NSTRIDS)
{
ret = composite_mkstrdesc(strid, buf);
}
#if DEV1_NSTRIDS > 0
else if (strid <= DEV1_STRIDBASE + DEV1_NSTRIDS)
{
ret = DEV1_MKSTRDESC(strid, buf);
}
#endif
#if DEV2_NSTRIDS > 0
else if (strid <= DEV2_STRIDBASE + DEV2_NSTRIDS)
{
ret = DEV2_MKSTRDESC(strid, buf);
}
#endif
}
break;
default:
{
usbtrace(TRACE_CLSERROR(USBCOMPOSITE_TRACEERR_GETUNKNOWNDESC), value);
}
break;
}
}
break;
case USB_REQ_SETCONFIGURATION:
{
if (ctrl->type == 0)
{
/* Save the configuration and inform the constituent classes */
ret = CLASS_SETUP(priv->dev1, dev, ctrl, dataout, outlen);
dispatched = true;
if (ret >= 0)
{
ret = CLASS_SETUP(priv->dev2, dev, ctrl, dataout, outlen);
if (ret >= 0)
{
priv->config = value;
}
}
}
}
break;
case USB_REQ_GETCONFIGURATION:
{
if (ctrl->type == USB_DIR_IN)
{
ctrlreq->buf[0] = priv->config;
ret = 1;
}
}
break;
case USB_REQ_SETINTERFACE:
{
if (ctrl->type == USB_REQ_RECIPIENT_INTERFACE &&
priv->config == COMPOSITE_CONFIGID)
{
ret = composite_classsetup(priv, dev, ctrl, dataout, outlen);
dispatched = true;
}
}
break;
case USB_REQ_GETINTERFACE:
{
if (ctrl->type == (USB_DIR_IN | USB_REQ_RECIPIENT_INTERFACE) &&
priv->config == COMPOSITE_CONFIGIDNONE)
{
ret = composite_classsetup(priv, dev, ctrl, dataout, outlen);
dispatched = true;
}
}
break;
default:
usbtrace(TRACE_CLSERROR(USBCOMPOSITE_TRACEERR_UNSUPPORTEDSTDREQ), ctrl->req);
break;
}
}
else
{
uint8_t recipient;
/**********************************************************************
* Non-Standard Class Requests
**********************************************************************/
/* Class implementations should handle there own interface and endpoint
* requests.
*/
recipient = ctrl->type & USB_REQ_RECIPIENT_MASK;
if (recipient == USB_REQ_RECIPIENT_INTERFACE || recipient == USB_REQ_RECIPIENT_ENDPOINT)
{
ret = composite_classsetup(priv, dev, ctrl, dataout, outlen);
dispatched = true;
}
}
/* Respond to the setup command if (1) data was returned, and (2) the request was
* NOT successfully dispatched to the component class driver. On an error return
* value (ret < 0), the USB driver will stall EP0.
*/
if (ret >= 0 && !dispatched)
{
/* Setup the request */
ctrlreq->len = MIN(len, ret);
ctrlreq->flags = USBDEV_REQFLAGS_NULLPKT;
/* And submit the request to the USB controller driver */
ret = EP_SUBMIT(dev->ep0, ctrlreq);
if (ret < 0)
{
usbtrace(TRACE_CLSERROR(USBCOMPOSITE_TRACEERR_EPRESPQ), (uint16_t)-ret);
ctrlreq->result = OK;
composite_ep0incomplete(dev->ep0, ctrlreq);
}
}
return ret;
}
hiya_reply_t*
hiya_6_svc(
prod_class_t *offered,
struct svc_req *rqstp)
{
const char* const pqfname = getQueuePath();
static hiya_reply_t reply;
SVCXPRT * const xprt = rqstp->rq_xprt;
struct sockaddr_in *upAddr = (struct sockaddr_in*) svc_getcaller(xprt);
const char *upName = hostbyaddr(upAddr);
int error;
int isPrimary;
unsigned int maxHereis;
static prod_class_t *accept;
/*
* Open the product-queue for writing. It will be closed by cleanup()
* during process termination.
*/
if (pq) {
(void) pq_close(pq);
pq = NULL;
}
error = pq_open(pqfname, PQ_DEFAULT, &pq);
if (error) {
err_log_and_free(ERR_NEW2(error, NULL,
"Couldn't open product-queue \"%s\" for writing: %s",
pqfname,
PQ_CORRUPT == error
? "The product-queue is inconsistent"
: strerror(error)), ERR_FAILURE);
svcerr_systemerr(xprt);
svc_destroy(xprt);
exit(error);
}
/* else */
error = down6_init(upName, upAddr, pqfname, pq);
if (error) {
uerror("Couldn't initialize downstream LDM");
svcerr_systemerr(xprt);
svc_destroy(xprt);
exit(error);
}
else {
uinfo("Downstream LDM initialized");
}
/*
* The previous "accept" is freed here -- rather than freeing the
* soon-to-be-allocated "accept" at the end of its block -- because it can
* be used in the reply.
*/
if (accept) {
free_prod_class(accept); /* NULL safe */
accept = NULL;
}
error = lcf_reduceToAcceptable(upName, inet_ntoa(upAddr->sin_addr), offered,
&accept, &isPrimary);
maxHereis = isPrimary ? UINT_MAX : 0;
if (error) {
serror("Couldn't validate HIYA");
svcerr_systemerr(xprt);
svc_destroy(xprt);
exit(error);
}
else {
if (ulogIsDebug())
udebug("intersection: %s", s_prod_class(NULL, 0, accept));
if (accept->psa.psa_len == 0) {
uwarn("Empty intersection of HIYA offer from %s (%s) and ACCEPT "
"entries", upName, s_prod_class(NULL, 0, offered));
svcerr_weakauth(xprt);
svc_destroy(xprt);
exit(0);
}
else {
error = down6_set_prod_class(accept);
if (error) {
if (DOWN6_SYSTEM_ERROR == error) {
serror("Couldn't set product class: %s",
s_prod_class(NULL, 0, accept));
}
else {
uerror("Couldn't set product class: %s",
s_prod_class(NULL, 0, accept));
}
svcerr_systemerr(xprt);
svc_destroy(xprt);
exit(EXIT_FAILURE);
}
/* else */
if (clss_eq(offered, accept)) {
unotice("hiya6: %s", s_prod_class(NULL, 0, offered));
reply.code = OK;
reply.hiya_reply_t_u.max_hereis = maxHereis;
}
else {
if (ulogIsVerbose()) {
char off[512];
char acc[512];
(void) s_prod_class(off, sizeof(off), offered), (void) s_prod_class(
acc, sizeof(acc), accept);
uinfo("hiya6: RECLASS: %s -> %s", off, acc);
}
reply.code = RECLASS;
reply.hiya_reply_t_u.feedPar.prod_class = accept;
reply.hiya_reply_t_u.feedPar.max_hereis = maxHereis;
}
} /* product-intersection != empty set */
} /* successful acl_check_hiya() */
return &reply;
}
int main(
int ac,
char *av[]
)
{
const char* const pqfname = getQueuePath();
const char* const progname = ubasename(av[0]);
int useProductID = FALSE;
int signatureFromId = FALSE;
char *productID = NULL;
int multipleFiles = FALSE;
char identifier[KEYSIZE];
int status;
int seq_start = 0;
enum ExitCode {
exit_success = 0, /* all files inserted successfully */
exit_system = 1, /* operating-system failure */
exit_pq_open = 2, /* couldn't open product-queue */
exit_infile = 3, /* couldn't process input file */
exit_dup = 4, /* input-file already in product-queue */
exit_md5 = 6 /* couldn't initialize MD5 processing */
} exitCode = exit_success;
#if !USE_MMAP
pqeIndex = PQE_NONE;
#endif
{
extern int optind;
extern int opterr;
extern char *optarg;
int ch;
(void) openulog(progname, LOG_NOTIME, LOG_LDM, "-");
(void) setulogmask(LOG_UPTO(LOG_NOTICE));
opterr = 0; /* Suppress getopt(3) error messages */
while ((ch = getopt(ac, av, ":ivxl:q:f:s:p:")) != EOF)
switch (ch) {
case 'i':
signatureFromId = 1;
break;
case 'v':
(void) setulogmask(getulogmask() | LOG_MASK(LOG_INFO));
break;
case 'x':
(void) setulogmask(getulogmask() | LOG_MASK(LOG_DEBUG));
break;
case 'l':
openulog(progname, ulog_get_options(), LOG_LDM, optarg);
break;
case 'q':
setQueuePath(optarg);
break;
case 's':
seq_start = atoi(optarg);
break;
case 'f':
feedtype = atofeedtypet(optarg);
if(feedtype == NONE)
{
fprintf(stderr, "Unknown feedtype \"%s\"\n", optarg);
usage(progname);
}
break;
case 'p':
useProductID = TRUE;
productID = optarg;
break;
case ':': {
LOG_ADD1("Option \"-%c\" requires an operand", optopt);
usage(progname);
}
/* no break */
default:
LOG_ADD1("Unknown option: \"%c\"", optopt);
usage(progname);
/* no break */
}
ac -= optind; av += optind ;
if(ac < 1) usage(progname);
}
/*
* register exit handler
*/
if(atexit(cleanup) != 0)
{
serror("atexit");
exit(exit_system);
}
/*
* set up signal handlers
*/
set_sigactions();
/*
* who am i, anyway
*/
(void) strncpy(myname, ghostname(), sizeof(myname));
myname[sizeof(myname)-1] = 0;
/*
* open the product queue
*/
if(status = pq_open(pqfname, PQ_DEFAULT, &pq))
{
if (PQ_CORRUPT == status) {
uerror("The product-queue \"%s\" is inconsistent\n",
pqfname);
}
else {
uerror("pq_open: \"%s\" failed: %s",
pqfname, status > 0 ? strerror(status) :
"Internal error");
}
exit(exit_pq_open);
}
{
char *filename;
int fd;
struct stat statb;
product prod;
MD5_CTX *md5ctxp = NULL;
/*
* Allocate an MD5 context
*/
md5ctxp = new_MD5_CTX();
if(md5ctxp == NULL)
{
serror("new_md5_CTX failed");
exit(exit_md5);
}
/* These members are constant over the loop. */
prod.info.origin = myname;
prod.info.feedtype = feedtype;
if (ac > 1) {
multipleFiles = TRUE;
}
for(prod.info.seqno = seq_start ; ac > 0 ;
av++, ac--, prod.info.seqno++)
{
filename = *av;
fd = open(filename, O_RDONLY, 0);
if(fd == -1)
{
serror("open: %s", filename);
exitCode = exit_infile;
continue;
}
if( fstat(fd, &statb) == -1)
{
serror("fstat: %s", filename);
(void) close(fd);
exitCode = exit_infile;
continue;
}
/* Determine what to use for product identifier */
if (useProductID)
{
if (multipleFiles)
{
sprintf(identifier,"%s.%d", productID, prod.info.seqno);
prod.info.ident = identifier;
}
else
prod.info.ident = productID;
}
else
prod.info.ident = filename;
prod.info.sz = statb.st_size;
prod.data = NULL;
/* These members, and seqno, vary over the loop. */
status = set_timestamp(&prod.info.arrival);
if(status != ENOERR) {
serror("set_timestamp: %s, filename");
exitCode = exit_infile;
continue;
}
#if USE_MMAP
prod.data = mmap(0, prod.info.sz,
PROT_READ, MAP_PRIVATE, fd, 0);
if(prod.data == NULL)
{
serror("mmap: %s", filename);
(void) close(fd);
exitCode = exit_infile;
continue;
}
status =
signatureFromId
? mm_md5(md5ctxp, prod.info.ident,
strlen(prod.info.ident), prod.info.signature)
: mm_md5(md5ctxp, prod.data, prod.info.sz,
prod.info.signature);
(void)exitIfDone(1);
if (status != 0) {
serror("mm_md5: %s", filename);
(void) munmap(prod.data, prod.info.sz);
(void) close(fd);
exitCode = exit_infile;
continue;
}
/* These members, and seqno, vary over the loop. */
status = set_timestamp(&prod.info.arrival);
if(status != ENOERR) {
serror("set_timestamp: %s, filename");
exitCode = exit_infile;
continue;
}
/*
* Do the deed
*/
status = pq_insert(pq, &prod);
switch (status) {
case ENOERR:
/* no error */
if(ulogIsVerbose())
uinfo("%s", s_prod_info(NULL, 0, &prod.info,
ulogIsDebug())) ;
break;
case PQUEUE_DUP:
uerror("Product already in queue: %s",
s_prod_info(NULL, 0, &prod.info, 1));
exitCode = exit_dup;
break;
case PQUEUE_BIG:
uerror("Product too big for queue: %s",
s_prod_info(NULL, 0, &prod.info, 1));
exitCode = exit_infile;
break;
case ENOMEM:
uerror("queue full?");
exitCode = exit_system;
break;
case EINTR:
#if defined(EDEADLOCK) && EDEADLOCK != EDEADLK
case EDEADLOCK:
/*FALLTHROUGH*/
#endif
case EDEADLK:
/* TODO: retry ? */
/*FALLTHROUGH*/
default:
uerror("pq_insert: %s", status > 0
? strerror(status) : "Internal error");
break;
}
(void) munmap(prod.data, prod.info.sz);
#else // USE_MMAP above; !USE_MMAP below
status =
signatureFromId
? mm_md5(md5ctxp, prod.info.ident,
strlen(prod.info.ident), prod.info.signature)
: fd_md5(md5ctxp, fd, statb.st_size,
prod.info.signature);
(void)exitIfDone(1);
if (status != 0) {
serror("xx_md5: %s", filename);
(void) close(fd);
exitCode = exit_infile;
continue;
}
if(lseek(fd, 0, SEEK_SET) == (off_t)-1)
{
serror("rewind: %s", filename);
(void) close(fd);
exitCode = exit_infile;
continue;
}
pqeIndex = PQE_NONE;
status = pqe_new(pq, &prod.info, &prod.data, &pqeIndex);
if(status != ENOERR) {
serror("pqe_new: %s", filename);
exitCode = exit_infile;
}
else {
ssize_t nread = read(fd, prod.data, prod.info.sz);
(void)exitIfDone(1);
if (nread != prod.info.sz) {
serror("read %s %u", filename, prod.info.sz);
status = EIO;
}
else {
status = pqe_insert(pq, pqeIndex);
pqeIndex = PQE_NONE;
switch (status) {
case ENOERR:
/* no error */
if(ulogIsVerbose())
uinfo("%s", s_prod_info(NULL, 0, &prod.info,
ulogIsDebug())) ;
break;
case PQUEUE_DUP:
uerror("Product already in queue: %s",
s_prod_info(NULL, 0, &prod.info, 1));
exitCode = exit_dup;
break;
case ENOMEM:
uerror("queue full?");
break;
case EINTR:
#if defined(EDEADLOCK) && EDEADLOCK != EDEADLK
case EDEADLOCK:
/*FALLTHROUGH*/
#endif
case EDEADLK:
/* TODO: retry ? */
/*FALLTHROUGH*/
default:
uerror("pq_insert: %s", status > 0
? strerror(status) : "Internal error");
}
} /* data read into `pqeIndex` region */
if (status != ENOERR) {
(void)pqe_discard(pq, pqeIndex);
pqeIndex = PQE_NONE;
}
} /* `pqeIndex` region allocated */
#endif
(void) close(fd);
} /* input-file loop */
free_MD5_CTX(md5ctxp);
} /* code block */
exit(exitCode);
}
void sam_usbsuspend(FAR struct usbdev_s *dev, bool resume)
{
uinfo("resume: %d\n", resume);
}
