// This function gets called when the timeout period of debounce timer elapses.
// It reports a switch change by completing a pending request
//
void HidFx2EvtTimerFunction(_In_ WDFTIMER hTimer)
{
WDFDEVICE hDevice = NULL;
WDFREQUEST hRequest;
PDEVICE_EXTENSION pDevContext = NULL;
NTSTATUS status = STATUS_SUCCESS;
size_t cBytesReturned = 0;
unsigned char bToggledSwitch = 0;
ULONG cBytesToCopy = 0;
PHIDFX2_IO_REPORT pInputReport = NULL;
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Enter\n");
hDevice = WdfTimerGetParentObject(hTimer);
pDevContext = GetDeviceContext(hDevice);
bToggledSwitch = pDevContext->bLatestToggledSwitch;
TraceInfo(DBG_IOCTL, "(%!FUNC!) mode %d switch %d\n", pDevContext->driverMode, bToggledSwitch);
if (!((pDevContext->driverMode == DM_BUTTON || pDevContext->driverMode == DM_BUTTON_AND_LED) && bToggledSwitch == 0))
{
// Check if there are any pending requests in the Interrupt Message Queue.
// If a request is found then complete the pending request.
status = WdfIoQueueRetrieveNextRequest(pDevContext->hInterruptMsgQueue, &hRequest);
if (NT_SUCCESS(status))
{
cBytesToCopy = sizeof(pInputReport[0]);
status = WdfRequestRetrieveOutputBuffer(hRequest,
cBytesToCopy,
&pInputReport,
&cBytesReturned); // BufferLength
if (NT_SUCCESS(status))
{
TraceInfo(DBG_IOCTL, "(%!FUNC!) WdfRequestRetrieveOutputBuffer switch %d\n", bToggledSwitch);
pInputReport->bReportId = GENERIC_DESKTOP_REPORT_ID;
pInputReport->bData = bToggledSwitch;
cBytesReturned = cBytesToCopy;
}
else // WdfRequestRetrieveOutputBuffer failed
{
TraceErr(DBG_IOCTL, "(%!FUNC!) WdfRequestRetrieveOutputBuffer failed with status: %!STATUS!\n", status);
}
WdfRequestCompleteWithInformation(hRequest, status, cBytesReturned);
}
else if (status != STATUS_NO_MORE_ENTRIES)
{
TraceErr(DBG_IOCTL, "(%!FUNC!) WdfIoQueueRetrieveNextRequest status %!STATUS!\n", status);
}
}
else
{
TraceInfo(DBG_IOCTL, "(%!FUNC!) ignore switch");
}
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit\n");
}
void httpsession_read(struct event *ev,int what, void *d)
{
size_t len=0;
size_t conten_len=0;
char *line=NULL;
char *ptr=NULL;
//ptr=buff_tail_ptr()
HttpSession *session = (HttpSession *)d;
len=buff_read(session->fd, session->request.buff, buff_tail_left(session->request.buff));
if(len<=0 )
goto fail;
while( (line=buff_get_line( session->request.buff,EOL_CRLF)) !=NULL )
{
if(session->request.prase_status==HPARSE_HEAD )
{
if( strlen(line)==0 )
{
session->request.prase_status=HPARSE_CONTENT;
break;
}
if(http_parse_head(&session->request, line) == -1)
{
TraceErr("http_parse_head fail\n");
goto fail;
}
continue;
}
if(session->request.prase_status==HPARSE_FIRST_LINE)
{
if(http_parse_first_line(&session->request,line)==-1)
goto fail;
session->request.prase_status=HPARSE_HEAD;
continue;
}
}
if(session->request.prase_status== HPARSE_CONTENT )
{
if(buff_len(session->request.buff) >= session->request.content_len)
{
session->request.prase_status = HPARSE_DONE;
if(httpserver_route_request(session)!=200)goto fail;
//if(session->server->request_callback(session,session->server->arg) != 0 )
// goto fail;
//event_fd_setflags(session->ev,EPOLLIN|EPOLLOUT);
//event_fd_setcallback(session->ev,httpsession_write);
event_fd_setcallback(session->ev,httpsession_file_write);
event_fd_setflags(session->ev,EPOLLOUT);
}
}
return;
fail:
TraceErr("httpsession_read fail\n");
httpserver_session_free(session);
return;
}
// Pass down Idle notification request to lower driver
//
NTSTATUS HidFx2SendIdleNotification(_In_ WDFREQUEST hRequest)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_REQUEST_SEND_OPTIONS options;
WDFIOTARGET hNextLowerDriver;
WDFDEVICE hDevice;
PIO_STACK_LOCATION pCurrentIrpStack = NULL;
IO_STACK_LOCATION nextIrpStack;
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Entry\n");
hDevice = WdfIoQueueGetDevice(WdfRequestGetIoQueue(hRequest));
pCurrentIrpStack = IoGetCurrentIrpStackLocation(WdfRequestWdmGetIrp(hRequest));
// Convert the request to corresponding USB Idle notification request
if (pCurrentIrpStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(HID_SUBMIT_IDLE_NOTIFICATION_CALLBACK_INFO))
{
ASSERT(sizeof(HID_SUBMIT_IDLE_NOTIFICATION_CALLBACK_INFO) == sizeof(USB_IDLE_CALLBACK_INFO));
#pragma warning(suppress :4127) // conditional expression is constant warning
if (sizeof(HID_SUBMIT_IDLE_NOTIFICATION_CALLBACK_INFO) == sizeof(USB_IDLE_CALLBACK_INFO))
{
// prepare next stack location
RtlZeroMemory(&nextIrpStack, sizeof(IO_STACK_LOCATION));
nextIrpStack.MajorFunction = pCurrentIrpStack->MajorFunction;
nextIrpStack.Parameters.DeviceIoControl.InputBufferLength = pCurrentIrpStack->Parameters.DeviceIoControl.InputBufferLength;
nextIrpStack.Parameters.DeviceIoControl.Type3InputBuffer = pCurrentIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
nextIrpStack.Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION;
nextIrpStack.DeviceObject = WdfIoTargetWdmGetTargetDeviceObject(WdfDeviceGetIoTarget(hDevice));
// Format the I/O request for the driver's local I/O target by using the contents of the specified WDM I/O stack location structure.
WdfRequestWdmFormatUsingStackLocation(hRequest, &nextIrpStack);
// Send the request down using Fire and forget option.
WDF_REQUEST_SEND_OPTIONS_INIT(&options, WDF_REQUEST_SEND_OPTION_SEND_AND_FORGET);
hNextLowerDriver = WdfDeviceGetIoTarget(hDevice);
if (WdfRequestSend(hRequest, hNextLowerDriver, &options) == FALSE)
{
status = STATUS_UNSUCCESSFUL;
}
}
else // Incorrect DeviceIoControl.InputBufferLength
{
status = STATUS_INFO_LENGTH_MISMATCH;
TraceErr(DBG_IOCTL, "(%!FUNC!) Incorrect DeviceIoControl.InputBufferLength, %!STATUS!\n", status);
return status;
}
}
else // DeviceIoControl.InputBufferLength too small
{
status = STATUS_BUFFER_TOO_SMALL;
TraceErr(DBG_IOCTL, "(%!FUNC!) DeviceIoControl.InputBufferLength too small, %!STATUS!\n", status);
return status;
}
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit = %!STATUS!\n", status);
return status;
}
int au_dpages_init(struct au_dcsub_pages *dpages, gfp_t gfp)
{
int err;
void *p;
TraceEnter();
err = -ENOMEM;
dpages->dpages = kmalloc(sizeof(*dpages->dpages), gfp);
if (unlikely(!dpages->dpages))
goto out;
p = (void*)__get_free_page(gfp);
if (unlikely(!p))
goto out_dpages;
dpages->dpages[0].ndentry = 0;
dpages->dpages[0].dentries = p;
dpages->ndpage = 1;
return 0; /* success */
out_dpages:
kfree(dpages->dpages);
out:
TraceErr(err);
return err;
}
//Installable driver initialization entry point. This entry point is called directly by the I/O system.
//
NTSTATUS DriverEntry (_In_ PDRIVER_OBJECT pDriverObject, _In_ PUNICODE_STRING pszRegistryPath)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
// Initialize WPP Tracing
WPP_INIT_TRACING(pDriverObject, pszRegistryPath);
TraceInfo(DBG_INIT, "(%!FUNC!) Enter -Sample Built %s %s\n", __DATE__, __TIME__);
WDF_DRIVER_CONFIG_INIT(&config, HidFx2EvtDeviceAdd);
// Register a cleanup callback so that we can call WPP_CLEANUP when the framework driver object is deleted during driver unload.
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = HidFx2EvtDriverContextCleanup;
// Create a framework driver object to represent our driver.
status = WdfDriverCreate(pDriverObject,
pszRegistryPath,
&attributes, // Driver Attributes
&config, // Driver Config Info
WDF_NO_HANDLE
);
if (!NT_SUCCESS(status))
{
TraceErr(DBG_INIT, "(%!FUNC!)WdfDriverCreate failed with status %!STATUS!\n", status);
WPP_CLEANUP(pDriverObject);
}
TraceVerbose(DBG_INIT, "(%!FUNC!) Exit\n");
return status;
}
// EvtDeviceD0Entry event callback must perform any operations that are necessary before the specified device is used.
// Called every time the hardware needs to be initialized/reinitialized.
// This function is not marked pageable because this function is in the device power up path.
// This function runs at PASSIVE_LEVEL, even though it is not paged.
//
NTSTATUS HidFx2EvtDeviceD0Entry(_In_ WDFDEVICE hDevice, _In_ WDF_POWER_DEVICE_STATE previousState)
{
PDEVICE_EXTENSION pDevContext = NULL;
NTSTATUS status = STATUS_SUCCESS;
unsigned char bSwitchState = 0;
unsigned char bMode = 0;
pDevContext = GetDeviceContext(hDevice);
TraceVerbose(DBG_PNP, "(%!FUNC!) Enter - coming from %S\n", DbgDevicePowerString(previousState));
SendVendorCommand(hDevice, HIDFX2_SET_BARGRAPH_DISPLAY, BARGRAPH_LED_ALL_OFF);
// Retrieve the current switch state and store it in device context
status = HidFx2GetSwitchState(hDevice, &bSwitchState);
if (NT_SUCCESS(status))
{
// Left most switches define Mode
bMode = bSwitchState & MODE_SELECTION_BUTTONS_BIT_MASK;
switch (bMode)
{
case SWITCHPACK_SELECTION_FOR_MODE2:
pDevContext->driverMode = DM_BUTTON_AND_LED;
SendVendorCommand(hDevice, HIDFX2_SET_7SEGMENT_DISPLAY, SEGMENT_DISPLAY_2);
break;
case SWITCHPACK_SELECTION_FOR_MODE3:
pDevContext->driverMode = DM_SLIDER_SWITCH;
SendVendorCommand(hDevice, HIDFX2_SET_7SEGMENT_DISPLAY, SEGMENT_DISPLAY_3);
break;
case SWITCHPACK_SELECTION_FOR_MODE4:
pDevContext->driverMode = DM_SLIDER_SWITCH_AND_LED;
SendVendorCommand(hDevice, HIDFX2_SET_7SEGMENT_DISPLAY, SEGMENT_DISPLAY_4);
break;
case SWITCHPACK_SELECTION_FOR_MODE5:
pDevContext->driverMode = DM_LED_ONLY;
SendVendorCommand(hDevice, HIDFX2_SET_7SEGMENT_DISPLAY, SEGMENT_DISPLAY_5);
break;
default:
pDevContext->driverMode = DM_BUTTON;
SendVendorCommand(hDevice, HIDFX2_SET_7SEGMENT_DISPLAY, SEGMENT_DISPLAY_1);
break;
}
pDevContext->bCurrentSwitchState = bSwitchState;
// Start the target. This will start the continuous reader
status = WdfIoTargetStart(WdfUsbTargetPipeGetIoTarget(pDevContext->hInterruptPipe));
if (NT_SUCCESS(status))
{
pDevContext->fIsPowerUpSwitchState = TRUE;
}
}
else
{
TraceErr(DBG_PNP, "(%!FUNC!) Failed to get current switch state, status: %!STATUS!\n", status);
}
TraceVerbose(DBG_PNP, "(%!FUNC!) Exit, status: %!STATUS!\n", status);
return status;
}
int au_dcsub_pages_rev(struct au_dcsub_pages *dpages, struct dentry *dentry,
int do_include, au_dpages_test test, void *arg)
{
int err;
TraceEnter();
err = 0;
spin_lock(&dcache_lock);
if (do_include && (!test || test(dentry, arg))) {
err = au_dpages_append(dpages, dentry, GFP_ATOMIC);
if (unlikely(err))
goto out;
}
while (!IS_ROOT(dentry)) {
dentry = dentry->d_parent;
if (!test || test(dentry, arg)) {
err = au_dpages_append(dpages, dentry, GFP_ATOMIC);
if (unlikely(err))
break;
}
}
out:
spin_unlock(&dcache_lock);
TraceErr(err);
return err;
}
// Fill in the given struct _HID_DEVICE_ATTRIBUTES
//
NTSTATUS HidFx2GetDeviceAttributes(_In_ WDFREQUEST hRequest)
{
NTSTATUS status = STATUS_SUCCESS;
PHID_DEVICE_ATTRIBUTES pDeviceAttributes = NULL;
PUSB_DEVICE_DESCRIPTOR pUsbDeviceDescriptor = NULL;
PDEVICE_EXTENSION pDeviceInfo = NULL;
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Entry\n");
pDeviceInfo = GetDeviceContext(WdfIoQueueGetDevice(WdfRequestGetIoQueue(hRequest)));
status = WdfRequestRetrieveOutputBuffer(hRequest, sizeof (HID_DEVICE_ATTRIBUTES), &pDeviceAttributes, NULL);
if (NT_SUCCESS(status))
{
// Retrieve USB device descriptor saved in device context
pUsbDeviceDescriptor = WdfMemoryGetBuffer(pDeviceInfo->hDeviceDescriptor, NULL);
pDeviceAttributes->Size = sizeof (HID_DEVICE_ATTRIBUTES);
pDeviceAttributes->VendorID = pUsbDeviceDescriptor->idVendor;
pDeviceAttributes->ProductID = pUsbDeviceDescriptor->idProduct;
pDeviceAttributes->VersionNumber = pUsbDeviceDescriptor->bcdDevice;
// Report how many bytes were copied
WdfRequestSetInformation(hRequest, sizeof (HID_DEVICE_ATTRIBUTES));
}
else // WdfRequestRetrieveOutputBuffer failed
{
TraceErr(DBG_IOCTL, "(%!FUNC!) WdfRequestRetrieveOutputBuffer failed %!STATUS!\n", status);
}
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit = %!STATUS!\n", status);
return status;
}
static int do_coo(struct dentry *dentry, aufs_bindex_t bstart)
{
int err;
struct dentry *parent, *h_parent, *h_dentry;
aufs_bindex_t bcpup;
struct inode *h_dir, *h_inode, *dir;
LKTRTrace("%.*s\n", DLNPair(dentry));
DEBUG_ON(IS_ROOT(dentry));
DiMustWriteLock(dentry);
parent = dentry->d_parent; // dget_parent()
di_write_lock_parent(parent);
bcpup = err = find_rw_parent_br(dentry, bstart);
//bcpup = err = find_rw_br(sb, bstart);
if (unlikely(err < 0)) {
err = 0; // stop copyup, it is not an error
goto out;
}
err = 0;
h_parent = au_h_dptr_i(parent, bcpup);
if (!h_parent) {
err = cpup_dirs(dentry, bcpup, NULL);
if (unlikely(err))
goto out;
h_parent = au_h_dptr_i(parent, bcpup);
}
h_dir = h_parent->d_inode;
h_dentry = au_h_dptr_i(dentry, bstart);
h_inode = h_dentry->d_inode;
dir = parent->d_inode;
hdir_lock(h_dir, dir, bcpup);
hi_lock_child(h_inode);
DEBUG_ON(au_h_dptr_i(dentry, bcpup));
err = sio_cpup_simple(dentry, bcpup, -1,
au_flags_cpup(CPUP_DTIME, parent));
TraceErr(err);
i_unlock(h_inode);
hdir_unlock(h_dir, dir, bcpup);
out:
di_write_unlock(parent);
TraceErr(err);
return err;
}
HttpServer *httpserver_new(short port,http_request_callback request,void *arg)
{
int sfp ;
//event *ev=NULL;
struct sockaddr_in s_add;
HttpServer *server=NULL;
int sin_size;
sfp = socket(AF_INET, SOCK_STREAM, 0);
if(-1 == sfp)
{
TraceErr("socket fail ! \r\n");
return NULL;
}
bzero(&s_add,sizeof(struct sockaddr_in));
s_add.sin_family=AF_INET;
s_add.sin_addr.s_addr=htonl(INADDR_ANY);
s_add.sin_port=htons(port);
if(-1 == bind(sfp,(struct sockaddr *)(&s_add), sizeof(struct sockaddr)))
{
TraceErr("[server]bind fail !\r\n");
return NULL;
}
TraceImport("[server]bind ok !\r\n");
if(-1 == listen(sfp,5))
{
TraceErr("[server]listen fail !\r\n");
return NULL;
}
TraceImport("[server]listen ok !\r\n");
fcntl( sfp, F_SETFL, O_NONBLOCK);
server= malloc(sizeof(HttpServer));
server->port=port;
server->request_callback=request;
server->arg=arg;
queue_init(&server->sessions);
queue_init(&server->routes);
server->ev=event_fd_new(sfp,EPOLLIN,httpserver_accept,server);
assert(server->ev);
return server;
}
int au_reopen_nondir(struct file *file)
{
int err;
struct dentry *dentry;
aufs_bindex_t bstart, bindex, bend;
struct file *hidden_file, *h_file_tmp;
dentry = file->f_dentry;
LKTRTrace("%.*s\n", DLNPair(dentry));
DEBUG_ON(S_ISDIR(dentry->d_inode->i_mode)
|| !au_h_dptr(dentry)->d_inode);
bstart = dbstart(dentry);
h_file_tmp = NULL;
if (fbstart(file) == bstart) {
hidden_file = au_h_fptr(file);
if (file->f_mode == hidden_file->f_mode)
return 0; /* success */
h_file_tmp = hidden_file;
get_file(h_file_tmp);
set_h_fptr(file, bstart, NULL);
}
DEBUG_ON(fbstart(file) < bstart
|| ftofi(file)->fi_hfile[0 + bstart].hf_file);
hidden_file = hidden_open(dentry, bstart, file->f_flags & ~O_TRUNC);
//if (LktrCond) {fput(hidden_file); br_put(stobr(dentry->d_sb, bstart));
//hidden_file = ERR_PTR(-1);}
err = PTR_ERR(hidden_file);
if (IS_ERR(hidden_file))
goto out; // close all?
err = 0;
//cpup_file_flags(hidden_file, file);
set_fbstart(file, bstart);
set_h_fptr(file, bstart, hidden_file);
memcpy(&hidden_file->f_ra, &file->f_ra, sizeof(file->f_ra)); //??
/* close lower files */
bend = fbend(file);
for (bindex = bstart + 1; bindex <= bend; bindex++)
set_h_fptr(file, bindex, NULL);
set_fbend(file, bstart);
out:
if (h_file_tmp)
fput(h_file_tmp);
TraceErr(err);
return err;
}
static int http_parse_http_version(const char *version, HttpRequest*req)
{
int major, minor;
char ch;
//printf("http_parse_http_version:%s\n",version);
int n = sscanf(version, "HTTP/%d.%d%c", &major, &minor, &ch);
if (n != 2 || major > 1) {
TraceErr("http_parse_http_version: bad version \n");
return (-1);
}
//printf("http_parse_http_version end\n");
req->major = major;
req->minor = minor;
return (0);
}
// This function gets the switch state of the USB device directly from the hardware
//
NTSTATUS HidFx2GetSwitchState(_In_ WDFDEVICE hDevice, _Out_ unsigned char *pbSwitchState)
{
PDEVICE_EXTENSION pDevContext = NULL;
NTSTATUS status = STATUS_SUCCESS;
WDF_MEMORY_DESCRIPTOR memDesc;
WDF_USB_CONTROL_SETUP_PACKET controlSetupPacket;
ULONG cBytesTransferred = 0;
if(pbSwitchState != NULL)
{
*pbSwitchState = 0;
}
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Entry\n");
pDevContext = GetDeviceContext(hDevice);
// set the segment state on the USB device
WDF_USB_CONTROL_SETUP_PACKET_INIT_VENDOR(&controlSetupPacket,
BmRequestDeviceToHost,
BmRequestToDevice,
HIDFX2_READ_SWITCH_STATE, // Request
0, // Value
0); // Index
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&memDesc, pbSwitchState, sizeof(*pbSwitchState));
status = WdfUsbTargetDeviceSendControlTransferSynchronously(pDevContext->hUsbDevice,
NULL, // Optional WDFREQUEST
NULL, // PWDF_REQUEST_SEND_OPTIONS
&controlSetupPacket,
&memDesc,
&cBytesTransferred);
if (!NT_SUCCESS(status))
{
TraceErr(DBG_IOCTL, "(%!FUNC!) Failed to read switch state - %!STATUS! \n", status);
}
else
{
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Switch state is 0x%x\n", *pbSwitchState);
*pbSwitchState = ~(*pbSwitchState); // switchs are inverted on hardware boards
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Switch state is 0x%x\n", *pbSwitchState);
}
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit, status: %!STATUS!\n", status);
return status;
}
//This routine sets the state of the Feature: in this case Segment Display on the USB FX2 board.
NTSTATUS SendVendorCommand(_In_ WDFDEVICE hDevice, _In_ unsigned char bVendorCommand, _In_ unsigned char bCommandData)
{
NTSTATUS status = STATUS_SUCCESS;
ULONG cBytesTransferred = 0;
PDEVICE_EXTENSION pDevContext = NULL;
WDF_MEMORY_DESCRIPTOR memDesc;
WDF_USB_CONTROL_SETUP_PACKET controlSetupPacket;
WDF_REQUEST_SEND_OPTIONS sendOptions;
PAGED_CODE();
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Enter\n");
pDevContext = GetDeviceContext(hDevice);
TraceInfo(DBG_IOCTL, "(%!FUNC!): Command:0x%x, data: 0x%x\n", bVendorCommand, bCommandData);
// Send the I/O with a timeout.
// We do that because we send the I/O in the context of the user thread and if it gets stuck, it would prevent the user process from existing.
WDF_REQUEST_SEND_OPTIONS_INIT(&sendOptions, WDF_REQUEST_SEND_OPTION_TIMEOUT);
WDF_REQUEST_SEND_OPTIONS_SET_TIMEOUT(&sendOptions, WDF_REL_TIMEOUT_IN_SEC(5));
WDF_USB_CONTROL_SETUP_PACKET_INIT_VENDOR(&controlSetupPacket,
BmRequestHostToDevice,
BmRequestToDevice,
bVendorCommand, // Request
0, // Value
0); // Index
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&memDesc, &bCommandData, sizeof(bCommandData));
status = WdfUsbTargetDeviceSendControlTransferSynchronously(pDevContext->hUsbDevice,
WDF_NO_HANDLE, // Optional WDFREQUEST
&sendOptions, // PWDF_REQUEST_SEND_OPTIONS
&controlSetupPacket,
&memDesc,
&cBytesTransferred);
if (!NT_SUCCESS(status))
{
TraceErr(DBG_IOCTL, "(%!FUNC!): Failed to set Segment Display state - %!STATUS!\n", status);
}
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit\n");
return status;
}
int buff_read(int fd,Buff *buff ,size_t len)
{
size_t cnt=0;
size_t left_len=0;
void *tail=NULL;
tail=buff_tail_ptr(buff);
left_len=buff_tail_left(buff);
if (left_len < len ){
TraceErr("buff_read: len not enough!!\n");
return -1;
}
cnt=read(fd,tail,len);
if(cnt>0)
buff->pad_len+=cnt;
//printf("buff_read:%d\n",cnt);
return cnt;
}
static void httpserver_accept(struct event *ev,int what, void *d)
{
int nfp;
HttpServer *server=(HttpServer*)d;
HttpSession *session=NULL;
struct sockaddr_in c_add;
size_t sin_size = sizeof(struct sockaddr_in);
nfp = accept(ev->ev.fd, (struct sockaddr *)(&c_add), &sin_size);
if(-1 == nfp)
{
TraceErr("accept fail !\r\n");
return ;
}
fcntl( nfp, F_SETFL, O_NONBLOCK);
//printf("[server]accept ok!\r\nServer start get connect from %#x : %#x\r\n",ntohl(c_add.sin_addr.s_addr),ntohs(c_add.sin_port));
session=httpserver_session_new(server,nfp);
event_fd_new(nfp,EPOLLIN,httpsession_read,session);
TraceImport("[server]accept ok! Server start get connect from %#x : %#x\r\n",ntohl(c_add.sin_addr.s_addr),ntohs(c_add.sin_port));
}
int au_is_subdir(struct dentry *d1, struct dentry *d2)
{
int err;
#ifndef AuUse_ISSUBDIR
int i, j;
struct au_dcsub_pages dpages;
struct au_dpage *dpage;
struct dentry **dentries;
#endif
LKTRTrace("%.*s, %.*s\n", DLNPair(d1), DLNPair(d2));
#ifdef AuUse_ISSUBDIR
spin_lock(&dcache_lock);
err = is_subdir(d1, d2);
spin_unlock(&dcache_lock);
#else
err = au_dpages_init(&dpages, GFP_KERNEL);
if (unlikely(err))
goto out;
err = au_dcsub_pages_rev(&dpages, d1, /*do_include*/1, NULL, NULL);
if (unlikely(err))
goto out_dpages;
for (i = dpages.ndpage - 1; !err && i >= 0; i--) {
dpage = dpages.dpages + i;
dentries = dpage->dentries;
for (j = dpage->ndentry - 1; !err && j >= 0; j--) {
struct dentry *d;
d = dentries[j];
//Dbg("d %.*s\n", DLNPair(d));
err = (d == d2);
}
}
out_dpages:
au_dpages_free(&dpages);
out:
#endif
TraceErr(err);
return err;
}
static ssize_t do_xino_fwrite(writef_t func, struct file *file, void *buf,
size_t size, loff_t *pos)
{
ssize_t err;
mm_segment_t oldfs;
lockdep_off();
oldfs = get_fs();
set_fs(KERNEL_DS);
do {
err = func(file, (const char __user*)buf, size, pos);
} while (err == -EAGAIN || err == -EINTR);
set_fs(oldfs);
lockdep_on();
#if 0
if (err > 0)
fsnotify_modify(file->f_dentry);
#endif
TraceErr(err);
return err;
}
static ssize_t xino_fread(readf_t func, struct file *file, void *buf,
size_t size, loff_t *pos)
{
ssize_t err;
mm_segment_t oldfs;
LKTRTrace("%.*s, sz %lu, *pos %Ld\n",
DLNPair(file->f_dentry), (unsigned long)size, *pos);
oldfs = get_fs();
set_fs(KERNEL_DS);
do {
err = func(file, (char __user*)buf, size, pos);
} while (err == -EAGAIN || err == -EINTR);
set_fs(oldfs);
#if 0
if (err > 0)
fsnotify_access(file->f_dentry);
#endif
TraceErr(err);
return err;
}
static int renwh_and_rmdir(struct dentry *dentry, aufs_bindex_t bindex,
struct aufs_nhash *whlist, struct inode *dir)
{
int rmdir_later, err;
struct dentry *hidden_dentry;
LKTRTrace("%.*s, b%d\n", DLNPair(dentry), bindex);
err = rename_whtmp(dentry, bindex);
//err = -1;
//todo: bug
if (unlikely(err)) {
au_direval_inc(dentry->d_parent);
return err;
}
hidden_dentry = au_h_dptr_i(dentry, bindex);
if (!au_is_nfs(hidden_dentry->d_sb)) {
const int dirwh = stosi(dentry->d_sb)->si_dirwh;
rmdir_later = (dirwh <= 1);
if (!rmdir_later)
rmdir_later = is_longer_wh(whlist, bindex, dirwh);
if (rmdir_later)
return rmdir_later;
}
err = rmdir_whtmp(hidden_dentry, whlist, bindex, dir, dentry->d_inode);
//err = -1;
if (unlikely(err)) {
IOErr("rmdir %.*s, b%d failed, %d. ignored\n",
DLNPair(hidden_dentry), bindex, err);
err = 0;
}
TraceErr(err);
return err;
}
// This routine configures a continuous reader on the interrupt endpoint. It's called from the PrepareHarware event.
//
NTSTATUS HidFx2ConfigContReaderForInterruptEndPoint(PDEVICE_EXTENSION pDeviceContext)
{
WDF_USB_CONTINUOUS_READER_CONFIG contReaderConfig;
NTSTATUS status = STATUS_SUCCESS;
PAGED_CODE ();
TraceVerbose(DBG_INIT, "(%!FUNC!) Enter\n");
WDF_USB_CONTINUOUS_READER_CONFIG_INIT(&contReaderConfig,
HidFx2EvtUsbInterruptPipeReadComplete,
pDeviceContext, // Context
sizeof(UCHAR)); // TransferLength
status = WdfUsbTargetPipeConfigContinuousReader(pDeviceContext->hInterruptPipe, &contReaderConfig);
if (!NT_SUCCESS(status))
{
TraceErr(DBG_INIT, "(%!FUNC!) failed %!STATUS!\n", status);
}
TraceVerbose(DBG_INIT, "(%!FUNC!) Exit, status: %!STATUS!\n", status);
return status;
}
int aufs_rmdir(struct inode *dir, struct dentry *dentry)
{
int err, rmdir_later;
struct inode *inode, *hidden_dir;
struct dentry *parent, *wh_dentry, *hidden_dentry, *hidden_parent;
struct dtime dt;
aufs_bindex_t bwh, bindex, bstart;
struct rmdir_whtmp_arg *arg;
struct aufs_nhash *whlist;
LKTRTrace("i%lu, %.*s\n", dir->i_ino, DLNPair(dentry));
IMustLock(dir);
inode = dentry->d_inode;
if (unlikely(!inode))
return -ENOENT; // possible?
IMustLock(inode);
whlist = nhash_new(GFP_KERNEL);
err = PTR_ERR(whlist);
if (IS_ERR(whlist))
goto out;
err = -ENOMEM;
arg = kmalloc(sizeof(*arg), GFP_KERNEL);
//arg = NULL;
if (unlikely(!arg))
goto out_whlist;
aufs_read_lock(dentry, AUFS_D_WLOCK);
parent = dentry->d_parent;
di_write_lock_parent(parent);
err = test_empty(dentry, whlist);
//err = -1;
if (unlikely(err))
goto out_arg;
bstart = dbstart(dentry);
bwh = dbwh(dentry);
bindex = -1;
wh_dentry = lock_hdir_create_wh(dentry, /*isdir*/ 1, &bindex, &dt);
//wh_dentry = ERR_PTR(-1);
err = PTR_ERR(wh_dentry);
if (IS_ERR(wh_dentry))
goto out_arg;
hidden_dentry = au_h_dptr(dentry);
dget(hidden_dentry);
hidden_parent = hidden_dentry->d_parent;
hidden_dir = hidden_parent->d_inode;
rmdir_later = 0;
if (bindex == bstart) {
IMustLock(hidden_dir);
err = renwh_and_rmdir(dentry, bstart, whlist, dir);
//err = -1;
if (err > 0) {
rmdir_later = err;
err = 0;
}
} else {
DEBUG_ON(!wh_dentry);
hidden_parent = wh_dentry->d_parent;
DEBUG_ON(hidden_parent != au_h_dptr_i(parent, bindex));
hidden_dir = hidden_parent->d_inode;
IMustLock(hidden_dir);
err = 0;
}
if (!err) {
au_reset_hinotify(inode, /*flags*/0);
inode->i_nlink = 0;
set_dbdiropq(dentry, -1);
epilog(dir, dentry, bindex);
if (rmdir_later) {
kick_rmdir_whtmp(hidden_dentry, whlist, bstart, dir,
inode, arg);
arg = NULL;
}
goto out_unlock; /* success */
}
/* revert */
LKTRLabel(revert);
if (wh_dentry) {
int rerr;
rerr = do_revert(err, wh_dentry, dentry, bwh, &dt,
need_dlgt(dir->i_sb));
if (rerr)
err = rerr;
}
out_unlock:
hdir_unlock(hidden_dir, dir, bindex);
dput(wh_dentry);
dput(hidden_dentry);
out_arg:
di_write_unlock(parent);
aufs_read_unlock(dentry, AUFS_D_WLOCK);
kfree(arg);
out_whlist:
nhash_del(whlist);
out:
TraceErr(err);
return err;
}
int request_file(HttpSession *session,char *rpath)
{
int fd;
const char *mime=NULL;
char *bname=NULL;
char *full_fath=NULL;
size_t path_len;
unsigned long filesize=0;
if(rpath==NULL)
{
path_len=strlen(session->request.path)+strlen(session->server->www_folder)+20;
full_fath=malloc(path_len);
sprintf(full_fath,"%s%s",session->server->www_folder,session->request.path);
}
else
{
full_fath=strdup(rpath);
}
//printf("mime:%s\n",mime);
if(is_file_dir(full_fath) == 1 && enum_index(full_fath)==-1)
{
TraceErr("path %s has no inde.* ,return 404 !\n",full_fath);
return 404;
}
TraceImport("request path:%s\n",full_fath);
filesize=get_file_size((const char*)full_fath);
if( filesize <= 0)
{
TraceErr("get_file_size %s fial,return 404 not found!\n",full_fath);
return 404;
}
fd=open((const char *)full_fath,O_RDONLY|O_NONBLOCK);
if(fd < 0 )
{
TraceErr("open %s fial,return 404 not found!\n",full_fath);
return 404;
}
TraceImport("open %s OK,size:%u !\n",full_fath,filesize);
//path_len=get_file_size(full_fath);
bname=basename(full_fath);
mime=get_mime(strrchr(bname,'.'));
if(mime!=NULL )
{
session->response=buff_new(1500,0);
buff_printf(session->response,"HTTP/1.0 200 OK\r\n");
buff_printf(session->response,"Server:whtc123\r\n");
buff_printf(session->response,"Content-type:%s\r\n",mime);
buff_printf(session->response,"Content-length:%d; charset=GBK\r\n",filesize);
buff_printf(session->response,"\r\n");
}
else
{
}
session->file_fd=fd;
event_fd_setcallback(session->ev,httpsession_file_write);
free(full_fath);
return 200;
}
// Finds the HID descriptor and copies it into the buffer provided by the Request.
//
NTSTATUS HidFx2GetHidDescriptor(_In_ WDFDEVICE hDevice, _In_ WDFREQUEST hRequest)
{
NTSTATUS status = STATUS_SUCCESS;
size_t cBytesToCopy = 0;
WDFMEMORY memory;
PDEVICE_EXTENSION pDevContext = NULL;
HID_DESCRIPTOR hidDescriptor;
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Entry\n");
status = WdfRequestRetrieveOutputMemory(hRequest, &memory);
if (NT_SUCCESS(status))
{
hidDescriptor.bLength= sizeof(hidDescriptor); // length of HID descriptor
hidDescriptor.bDescriptorType= HID_HID_DESCRIPTOR_TYPE; // descriptor type == HID 0x21
hidDescriptor.bcdHID= HID_CLASS_SPEC_RELEASE_1_00; // hid spec release
hidDescriptor.bCountry= HID_COUNTRY_NON_LOCALIZED; // country code
hidDescriptor.bNumDescriptors= 0x01; // number of HID class descriptors
hidDescriptor.DescriptorList[0].bReportType =HID_REPORT_DESCRIPTOR_TYPE;
hidDescriptor.DescriptorList[0].wReportLength = sizeof(c_ButtonDescriptor);
pDevContext = GetDeviceContext(hDevice);
if (pDevContext != NULL)
{
// Set length of non default report descriptor
switch (pDevContext->driverMode)
{
case DM_BUTTON_AND_LED:
hidDescriptor.DescriptorList[0].wReportLength = sizeof(c_ButtonWithLedDescriptor);
break;
case DM_SLIDER_SWITCH:
hidDescriptor.DescriptorList[0].wReportLength = sizeof(c_SliderSwitchDescriptor);
break;
case DM_SLIDER_SWITCH_AND_LED:
hidDescriptor.DescriptorList[0].wReportLength = sizeof(c_SliderSwitchWithLedDescriptor);
break;
case DM_LED_ONLY:
hidDescriptor.DescriptorList[0].wReportLength = sizeof(c_LedOnlyDescriptor);
break;
default:
break;
}
}
cBytesToCopy = hidDescriptor.bLength;
if (cBytesToCopy != 0)
{
status = WdfMemoryCopyFromBuffer(memory, 0, (PVOID)&hidDescriptor, cBytesToCopy);
if (NT_SUCCESS(status))
{
// Report how many bytes were copied
WdfRequestSetInformation(hRequest, cBytesToCopy);
}
else // WdfMemoryCopyFromBuffer failed
{
TraceErr(DBG_IOCTL, "(%!FUNC!) WdfMemoryCopyFromBuffer failed %!STATUS!\n", status);
return status;
}
}
else // length is zero
{
status = STATUS_INVALID_DEVICE_STATE;
TraceErr(DBG_IOCTL, "(%!FUNC!) c_DefaultHidDescriptor is zero, %!STATUS!\n", status);
return status;
}
}
else // WdfRequestRetrieveOutputMemory failed
{
TraceErr(DBG_IOCTL, " (%!FUNC!) WdfRequestRetrieveOutputMemory failed %!STATUS!\n", status);
return status;
}
TraceVerbose(DBG_IOCTL, " (%!FUNC!) HidFx2GetHidDescriptor Exit = %!STATUS!\n", status);
return status;
}
// Finds the Report descriptor and copies it into the buffer provided by the Request.
//
NTSTATUS HidFx2GetReportDescriptor(_In_ WDFDEVICE hDevice, _In_ WDFREQUEST hRequest)
{
NTSTATUS status = STATUS_SUCCESS;
WDFMEMORY memory;
PDEVICE_EXTENSION pDevContext = NULL;
PVOID pBuffer = (PVOID)c_ButtonDescriptor;
size_t cBytesToCopy = sizeof(c_ButtonDescriptor);
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Entry\n");
status = WdfRequestRetrieveOutputMemory(hRequest, &memory);
if (NT_SUCCESS(status))
{
pDevContext = GetDeviceContext(hDevice);
if (pDevContext != NULL)
{
// Select a non default report descriptor
switch (pDevContext->driverMode)
{
case DM_BUTTON_AND_LED:
pBuffer = (PVOID)c_ButtonWithLedDescriptor;
cBytesToCopy = sizeof(c_ButtonWithLedDescriptor);
break;
case DM_SLIDER_SWITCH:
pBuffer = (PVOID)c_SliderSwitchDescriptor;
cBytesToCopy = sizeof(c_SliderSwitchDescriptor);
break;
case DM_SLIDER_SWITCH_AND_LED:
pBuffer = (PVOID)c_SliderSwitchWithLedDescriptor;
cBytesToCopy = sizeof(c_SliderSwitchWithLedDescriptor);
break;
case DM_LED_ONLY:
pBuffer = (PVOID)c_LedOnlyDescriptor;
cBytesToCopy = sizeof(c_LedOnlyDescriptor);
break;
default:
break;
}
}
if (cBytesToCopy != 0)
{
status = WdfMemoryCopyFromBuffer(memory, 0, pBuffer, cBytesToCopy);
if (NT_SUCCESS(status))
{
// Report how many bytes were copied
WdfRequestSetInformation(hRequest, cBytesToCopy);
}
else // WdfMemoryCopyFromBuffer failed
{
TraceErr(DBG_IOCTL, "(%!FUNC!) WdfMemoryCopyFromBuffer failed %!STATUS!\n", status);
}
}
else // report length is zero
{
status = STATUS_INVALID_DEVICE_STATE;
TraceErr(DBG_IOCTL, "(%!FUNC!) c_DefaultHidDescriptor's reportLength is zero, %!STATUS!\n", status);
}
}
else // WdfRequestRetrieveOutputMemory failed
{
TraceErr(DBG_IOCTL, "(%!FUNC!)WdfRequestRetrieveOutputMemory failed %!STATUS!\n", status);
}
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit = %!STATUS!\n", status);
return status;
}
void httpsession_file_write(struct event *ev,int what, void *d)
{
HttpSession *session = (HttpSession *)d;
Buff *buff=session->response;
int file_fd=session->file_fd;
int len=0;
/*here is most send http head or fail with EAGAIN*/
if(buff_len(buff)>0 )
{
len=buff_write(session->fd,buff,buff_len(buff));
if(len<0)
{
if(errno == EAGAIN)
{
return;
}
}
}
while(1)
{
buff_set_startpos( buff,0);
/*read file*/
do
{
len=buff_read(file_fd,buff,buff_tail_left(buff));
if(len == 0 )
{
httpserver_session_free( session);
return;
}
if(len == -1)
{
if(errno == EAGAIN)
{
continue;
}
TraceErr("read file fail:%s\n",strerror(errno));
httpserver_session_free( session);
return ;
}
}while(0);
session->total_read+=len;
/*send out*/
len=buff_write(session->fd,buff,buff_len(buff));
if(len<0)
{
/*socket buff full,try again*/
if(errno == EAGAIN)
{
return;
}
/*error free session*/
TraceErr("session write:FAIL\n");
httpserver_session_free( session);
break;
}
//printf("session write:%u\n",len);
}
}
NTSTATUS HidFx2SetOutput(_In_ WDFREQUEST hRequest)
{
NTSTATUS status = STATUS_SUCCESS;
PHID_XFER_PACKET pTransferPacket = NULL;
WDF_REQUEST_PARAMETERS params;
PHIDFX2_IO_REPORT pOutputReport = NULL;
WDFDEVICE hDevice;
PAGED_CODE();
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Enter\n");
hDevice = WdfIoQueueGetDevice(WdfRequestGetIoQueue(hRequest));
WDF_REQUEST_PARAMETERS_INIT(¶ms);
WdfRequestGetParameters(hRequest, ¶ms);
if (params.Parameters.DeviceIoControl.InputBufferLength < sizeof(HID_XFER_PACKET))
{
status = STATUS_BUFFER_TOO_SMALL;
TraceErr(DBG_IOCTL, "(%!FUNC!) Userbuffer is small %!STATUS!\n", status);
return status;
}
pTransferPacket = (PHID_XFER_PACKET) WdfRequestWdmGetIrp(hRequest)->UserBuffer;
if (pTransferPacket == NULL)
{
status = STATUS_INVALID_DEVICE_REQUEST;
TraceErr(DBG_IOCTL, "(%!FUNC!) Irp->UserBuffer is NULL %!STATUS!\n", status);
return status;
}
if (pTransferPacket->reportBufferLen == 0)
{
status = STATUS_BUFFER_TOO_SMALL;
TraceErr(DBG_IOCTL, "(%!FUNC!) HID_XFER_PACKET->reportBufferLen is 0, %!STATUS!\n", status);
return status;
}
if (pTransferPacket->reportBufferLen < sizeof(UCHAR))
{
status = STATUS_BUFFER_TOO_SMALL;
TraceErr(DBG_IOCTL, "(%!FUNC!) HID_XFER_PACKET->reportBufferLen is too small, %!STATUS!\n", status);
return status;
}
if (pTransferPacket->reportId != GENERIC_DESKTOP_REPORT_ID)
{
status = STATUS_INVALID_DEVICE_REQUEST;
TraceErr(DBG_IOCTL, "(%!FUNC!) Incorrect report ID, %!STATUS!\n", status);
return status;
}
pOutputReport = (PHIDFX2_IO_REPORT)pTransferPacket->reportBuffer;
if (pOutputReport->bData == 0)
{
status = SendVendorCommand(hDevice, HIDFX2_SET_BARGRAPH_DISPLAY, BARGRAPH_LED_ALL_OFF);
}
else
{
status = SendVendorCommand(hDevice, HIDFX2_SET_BARGRAPH_DISPLAY, BARGRAPH_LED_ALL_ON);
}
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit status %!STATUS!\n", status);
return status;
}
NTSTATUS HidFx2GetInput(_In_ WDFREQUEST hRequest)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_REQUEST_PARAMETERS params;
WDFDEVICE hDevice;
PHID_XFER_PACKET pTransferPacket = NULL;
PHIDFX2_IO_REPORT pOutputReport = NULL;
unsigned char bSwitchState = 0;
PAGED_CODE();
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Enter\n");
hDevice = WdfIoQueueGetDevice(WdfRequestGetIoQueue(hRequest));
WDF_REQUEST_PARAMETERS_INIT(¶ms);
WdfRequestGetParameters(hRequest, ¶ms);
if (params.Parameters.DeviceIoControl.OutputBufferLength < sizeof(HID_XFER_PACKET))
{
status = STATUS_BUFFER_TOO_SMALL;
TraceErr(DBG_IOCTL, "(%!FUNC!) Userbuffer is small %!STATUS!\n", status);
return status;
}
pTransferPacket = (PHID_XFER_PACKET) WdfRequestWdmGetIrp(hRequest)->UserBuffer;
if (pTransferPacket == NULL)
{
status = STATUS_INVALID_DEVICE_REQUEST;
TraceErr(DBG_IOCTL, "(%!FUNC!) Irp->UserBuffer is NULL %!STATUS!\n", status);
return status;
}
if (pTransferPacket->reportBufferLen == 0)
{
status = STATUS_BUFFER_TOO_SMALL;
TraceErr(DBG_IOCTL, "(%!FUNC!) HID_XFER_PACKET->reportBufferLen is 0, %!STATUS!\n", status);
return status;
}
if (pTransferPacket->reportBufferLen < sizeof(UCHAR))
{
status = STATUS_BUFFER_TOO_SMALL;
TraceErr(DBG_IOCTL, "(%!FUNC!) HID_XFER_PACKET->reportBufferLen is too small, %!STATUS!\n", status);
return status;
}
if (pTransferPacket->reportId != GENERIC_DESKTOP_REPORT_ID)
{
status = STATUS_INVALID_DEVICE_REQUEST;
TraceErr(DBG_IOCTL, "(%!FUNC!) Incorrect report ID, %!STATUS!\n", status);
return status;
}
pOutputReport = (PHIDFX2_IO_REPORT)pTransferPacket->reportBuffer;
// Get the switch state directly from the hardware
status = HidFx2GetSwitchState(hDevice, &bSwitchState);
TraceVerbose(DBG_IOCTL, "(%!FUNC!) switch state 0x%x\n", bSwitchState);
//Mask off everything except the actual switch bit
bSwitchState &= RADIO_SWITCH_BUTTONS_BIT_MASK;
TraceVerbose(DBG_IOCTL, "(%!FUNC!) maskedswitch state 0x%x\n", bSwitchState);
pOutputReport->bReportId = GENERIC_DESKTOP_REPORT_ID;
pOutputReport->bData = bSwitchState;
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit status %!STATUS!\n", status);
return status;
}
// This event is called when the framework receives IRP_MJ_INTERNAL DEVICE_CONTROL requests from the system.
//
void HidFx2EvtInternalDeviceControl(
_In_ WDFQUEUE hQueue,
_In_ WDFREQUEST hRequest,
_In_ size_t cOutputBufferLength,
_In_ size_t cInputBufferLength,
_In_ ULONG ulIoControlCode
)
{
NTSTATUS status = STATUS_SUCCESS;
WDFDEVICE hDevice;
PDEVICE_EXTENSION pDevContext = NULL;
UNREFERENCED_PARAMETER(cOutputBufferLength);
UNREFERENCED_PARAMETER(cInputBufferLength);
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Enter\n");
hDevice = WdfIoQueueGetDevice(hQueue);
pDevContext = GetDeviceContext(hDevice);
TraceInfo(DBG_IOCTL, "(%!FUNC!) Queue:0x%p, Request:0x%p\n", hQueue, hRequest);
switch (ulIoControlCode)
{
case IOCTL_HID_GET_DEVICE_DESCRIPTOR:
TraceInfo(DBG_IOCTL, "IOCTL_HID_GET_DEVICE_DESCRIPTOR\n");
status = HidFx2GetHidDescriptor(hDevice, hRequest);
WdfRequestComplete(hRequest, status);
break;
case IOCTL_HID_GET_DEVICE_ATTRIBUTES:
TraceInfo(DBG_IOCTL, "IOCTL_HID_GET_DEVICE_ATTRIBUTES\n");
status = HidFx2GetDeviceAttributes(hRequest);
WdfRequestComplete(hRequest, status);
break;
case IOCTL_HID_GET_REPORT_DESCRIPTOR:
TraceInfo(DBG_IOCTL, "IOCTL_HID_GET_REPORT_DESCRIPTOR\n");
status = HidFx2GetReportDescriptor(hDevice, hRequest);
WdfRequestComplete(hRequest, status);
break;
case IOCTL_HID_READ_REPORT:
TraceInfo(DBG_IOCTL, "IOCTL_HID_READ_REPORT\n");
status = WdfRequestForwardToIoQueue(hRequest, pDevContext->hInterruptMsgQueue);
if (!NT_SUCCESS(status))
{
TraceErr(DBG_IOCTL, "WdfRequestForwardToIoQueue failed with status: %!STATUS!\n", status);
WdfRequestComplete(hRequest, status);
}
break;
case IOCTL_HID_SEND_IDLE_NOTIFICATION_REQUEST:
TraceInfo(DBG_IOCTL, "IOCTL_HID_SEND_IDLE_NOTIFICATION_REQUEST\n");
status = HidFx2SendIdleNotification(hRequest);
if (!NT_SUCCESS(status))
{
TraceErr(DBG_IOCTL, "SendIdleNotification failed with status: %!STATUS!\n", status);
WdfRequestComplete(hRequest, status);
}
break;
case IOCTL_HID_GET_INPUT_REPORT:
TraceInfo(DBG_IOCTL, "IOCTL_HID_GET_INPUT_REPORT\n");
HidFx2GetInput(hRequest);
WdfRequestComplete(hRequest, status);
break;
case IOCTL_HID_SET_OUTPUT_REPORT:
TraceInfo(DBG_IOCTL, "IOCTL_HID_SET_OUTPUT_REPORT\n");
status = HidFx2SetOutput(hRequest);
WdfRequestComplete(hRequest, status);
break;
default:
TraceInfo(DBG_IOCTL, "IOCTL Not Supported 0x%X\n", ulIoControlCode);
status = STATUS_NOT_SUPPORTED;
WdfRequestComplete(hRequest, status);
break;
}
TraceVerbose(DBG_IOCTL, "(%!FUNC!) Exit\n");
return;
}
static int http_parse_first_line( HttpRequest *req, char *line)
{
char *method;
char *uri;
char *version;
char *query;
char *fragment;
const char *hostname;
const char *scheme;
//printf("http_parse_first_line start\n");
//printf("line:%s\n",line);
/* Parse the request line */
method = strsep(&line, " ");
if (line == NULL)
return (-1);
uri = strsep(&line, " ");
if (line == NULL)
return (-1);
version = strsep(&line, " ");
if (line != NULL)
return (-1);
//printf("http_parse_first_line:1\n");
query=strchr(uri,'?');
if(query!=NULL )
{
*query='\0';
query++;
fragment=strrchr(query,'#');
}
else
{
fragment=strrchr(uri,'#');
}
if(fragment!=NULL )
{
*fragment='\0';
fragment++;
}
//printf("http_parse_first_line 1\n");
/* First line */
if (strcmp(method, "GET") == 0) {
req->type = HTTP_GET;
} else if (strcmp(method, "POST") == 0) {
req->type = HTTP_POST;
} else if (strcmp(method, "HEAD") == 0) {
req->type = HTTP_HEAD;
} else if (strcmp(method, "PUT") == 0) {
req->type = HTTP_PUT;
} else if (strcmp(method, "DELETE") == 0) {
req->type = HTTP_DELETE;
} else if (strcmp(method, "OPTIONS") == 0) {
req->type = HTTP_OPTIONS;
} else if (strcmp(method, "TRACE") == 0) {
req->type = HTTP_TRACE;
} else if (strcmp(method, "PATCH") == 0) {
req->type = HTTP_PATCH;
} else {
req->type = HTTP_UNKNOWN;
TraceErr("bad request method:%s\n",method);
/* No error yet; we'll give a better error later when
* we see that req->type is unsupported. */
}
//printf("http_parse_first_line 2\n");
req->path=uri;
req->query=query;
req->fragment=fragment;
if (http_parse_http_version(version, req) < 0)
return (-1);
//printf("http_parse_first_line 3\n");
return (0);
}
