开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 文章/文档 > 通讯编程文档 > 查看源码
ioctl.c
资源名称：虚拟串口驱动程序.rar　[点击查看]
上传用户：zanmei2
上传日期：2010-03-06
资源大小：775k
文件大小：21k
源码类别：

通讯编程文档

开发平台：

C/C++

ioctl.c：源码内容
  1. /*++
  3. Copyright (c) 2005  Changzhi Zhou All Rights Reserved
  5. Module Name:
  7.     ioctl.c
  9. Abstract:
  11.     This module handles Device I/O control requests.
  13. Environment:
  15.     Kernel mode
  17. Revision History:
  18. Changzhi Zhou Dec 20  2004
  20. --*/
  21. #include <ntddk.h>
  22. #include <initguid.h>
  23. #include "main.h"
  24. #include "..incwdmioctl.h"
  27. NTSTATUS SampleIoControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
  28. /*++
  30. Routine Description:
  32.     The evice I/O control handle.
  33. All handle relevant to Serial Port are deal with here.
  35. Arguments:
  37.    DeviceObject - pointer to a device object.
  39.    Irp - pointer to an I/O Request Packet.
  41. Return Value:
  43.       NT status code
  45. --*/
  46. {
  47. PIO_STACK_LOCATION IrpStack;
  48. ULONG ControlCode;
  49. ULONG InputLength,OutputLength;
  50. NTSTATUS status;
  51. ULONG info;
  52. PUCHAR Buffer;
  53. PDEVICE_EXTENSION deviceExtension;
  55. KIRQL oldIrql;
  57. PAGED_CODE();
  59. deviceExtension = DeviceObject->DeviceExtension;
  60. if ( deviceExtension->DevicePnPState != Working)
  61. {
  62. status = STATUS_INVALID_DEVICE_STATE;
  63. return CompleteRequest(Irp, status, 0);
  64.     }
  65. IrpStack = IoGetCurrentIrpStackLocation(Irp);
  66. DebugPrint(("SampleIoControl: IrpStack 0x%08xn", IrpStack ));
  68. ControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
  69. InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
  70. OutputLength= IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
  71. info = 0;
  72. status = STATUS_SUCCESS;
  73. SampleIoIncrement ( deviceExtension );
  74. switch(ControlCode)
  75. {
  76. case IOCTL_CREATE_DOS_NAME:
  77. // create DosName, such as COM5.
  78. //
  79. status = CreateDosName( DeviceObject, Irp );
  80. break;
  81. case IOCTL_DELETE_DOS_NAME:
  82. status = SerialUndoExternalNaming( deviceExtension );
  83. break;
  84. case IOCTL_SET_REMOTE_INFO:
  85. if ( InputLength < ( sizeof ( ULONG ) * 2 ) )
  86. {
  87. status = STATUS_BUFFER_TOO_SMALL;
  88. break;
  89. }
  90. deviceExtension->RemoteAddress = *((ULONG *)Irp->AssociatedIrp.SystemBuffer);
  91. deviceExtension->RemotePort = (USHORT)*( ((ULONG *)Irp->AssociatedIrp.SystemBuffer) + 1);
  92. break;
  93. case IOCTL_QUERY_NETWORK_INFORMATION:
  94. if ( ( InputLength < sizeof( ULONG ) ) || ( OutputLength < sizeof ( ULONG ) ) )
  95. {
  96. status = STATUS_BUFFER_TOO_SMALL;
  97. break;
  98. }
  99. status = TDIQueryNetworkInformation ( DeviceObject, Irp );
  100. info = Irp->IoStatus.Information;
  101. break;
  102. case IOCTL_SERIAL_SET_WAIT_MASK:
  103. {
  104. ULONG NewMask;
  105. if ( IrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG)) {
  106. status = STATUS_BUFFER_TOO_SMALL;
  107. break;
  108. }else{
  109. NewMask = *((ULONG *)Irp->AssociatedIrp.SystemBuffer);
  110. }
  111. DebugPrint(("--  IOCTL_SERIAL_SET_WAIT_MASK   --n"));
  113. if (NewMask & ~(SERIAL_EV_RXCHAR   |
  114. SERIAL_EV_RXFLAG   |
  115. SERIAL_EV_TXEMPTY  |
  116. SERIAL_EV_CTS      |
  117. SERIAL_EV_DSR      |
  118. SERIAL_EV_RLSD     |
  119. SERIAL_EV_BREAK    |
  120. SERIAL_EV_ERR      |
  121. SERIAL_EV_RING     |
  122. SERIAL_EV_PERR     |
  123. SERIAL_EV_RX80FULL |
  124. SERIAL_EV_EVENT1   |
  125. SERIAL_EV_EVENT2)) {
  126. DebugPrint(("SERIAL: Unknown mask %xn",NewMask));
  127. status = STATUS_INVALID_PARAMETER;
  128. break;
  129. }
  130. DebugPrint(("Set wait mask:   0x%xn", NewMask ));
  131. KeAcquireSpinLock ( &deviceExtension->ThreadSpinLock, &oldIrql );
  132. //
  133. // Set wait mask means that we will wait NEW mask.
  134. // So we must complete WaitOnMaskIrp and PendingReadIrp
  135. //
  136. if( deviceExtension->WaitOnMaskIrp ){
  137. // 取消上一次的WAIT_ON_MASK Irp
  138. *((ULONG *)deviceExtension->WaitOnMaskIrp->AssociatedIrp.SystemBuffer) = 0;
  139. CompleteRequest( deviceExtension->WaitOnMaskIrp, STATUS_SUCCESS, sizeof( ULONG ));
  140. SampleIoDecrement( deviceExtension );
  141. deviceExtension->WaitOnMaskIrp = NULL;
  142. }
  143. deviceExtension->WaitMask = NewMask;
  144. KeReleaseSpinLock ( &deviceExtension->ThreadSpinLock, oldIrql );
  145. status = STATUS_SUCCESS;
  146. break;
  147. }
  148. case IOCTL_SERIAL_WAIT_ON_MASK:
  149. {
  150. ULONG RetMask;
  151. DebugPrint(("--  IOCTL_SERIAL_WAIT_ON_MASK   --n"));
  153. if ( IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)) {
  154. DebugPrint(("SERIAL: Invalid size for the buffer %dn",
  155. IrpStack->Parameters.DeviceIoControl.OutputBufferLength));
  156. status = STATUS_BUFFER_TOO_SMALL;
  157. break;
  158. }
  159. KeAcquireSpinLock ( &deviceExtension->ThreadSpinLock, &oldIrql );
  160. if( deviceExtension->WaitOnMaskIrp ){
  161. DebugPrint(("There is a wait-on-mask request already pendingn"));
  162. status = STATUS_INVALID_PARAMETER;
  163. KeReleaseSpinLock ( &deviceExtension->ThreadSpinLock, oldIrql );
  164. break;
  165. }
  166. // Mark the Irp here. Then we check COMMSTATUS at intervals in another thread
  167. // to determine whether or not to complete this Irp.
  168. //
  169. DebugPrint(("MarkIrpPendingn"));
  170. IoMarkIrpPending( Irp );
  171. ASSERT( deviceExtension->WaitOnMaskIrp == NULL );
  172. deviceExtension->WaitOnMaskIrp = Irp;
  173. KeReleaseSpinLock ( &deviceExtension->ThreadSpinLock, oldIrql );
  175. status = STATUS_PENDING;
  176. return status;
  177. }
  178. case IOCTL_SERIAL_PURGE:
  179. {
  180. ULONG PurgeMask;
  181. DebugPrint(("--   IOCTL_SERIAL_PURGE  --n"));
  182. if ( IrpStack->Parameters.DeviceIoControl.InputBufferLength <
  183. sizeof( ULONG )) {
  184. DebugPrint(("Serial purge output buffer too smalln"));
  185. status = STATUS_BUFFER_TOO_SMALL;
  186. break;
  187. }
  188. PurgeMask = *(PULONG)Irp->AssociatedIrp.SystemBuffer;
  189. DebugPrint(("IOCTL_SERIAL_PURGE:   0x%xn", PurgeMask));
  190. KeAcquireSpinLock( &deviceExtension->ThreadSpinLock, &oldIrql );
  191. if( ( PurgeMask & SERIAL_PURGE_RXABORT ) || ( PurgeMask & SERIAL_PURGE_RXCLEAR ) ){
  192. // purge Rx buffer and complete PendingReadIrp
  193. DebugPrint(( "SERIAL_PURGE_RXABORTn" ));
  194. deviceExtension->SerialStatus.AmountInInQueue = 0;
  195. deviceExtension->lpRx = deviceExtension->RxBuffer;
  196. deviceExtension->lpRead = deviceExtension->RxBuffer;
  197. }
  198. if ( ( PurgeMask & SERIAL_PURGE_TXABORT ) || ( PurgeMask & SERIAL_PURGE_TXCLEAR ) ){
  199. // purge Tx buffer
  200. DebugPrint(( "SERIAL_PURGE_TXABORTn" ));
  201. }
  202. KeReleaseSpinLock ( &deviceExtension->ThreadSpinLock, oldIrql );
  203. info = sizeof( ULONG );
  204. status = STATUS_SUCCESS;
  205. break;
  206. }
  208. case IOCTL_SERIAL_GET_COMMSTATUS:
  209. {
  210. DebugPrint(("--  IOCTL_SERIAL_GET_COMMSTATUS   --n"));
  211. if( IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof( SERIAL_STATUS ) ){
  212. status = STATUS_BUFFER_TOO_SMALL;
  213. break;
  214. }
  215. KeAcquireSpinLock ( &deviceExtension->ThreadSpinLock, &oldIrql );
  216. RtlCopyMemory( Irp->AssociatedIrp.SystemBuffer, &deviceExtension->SerialStatus, sizeof ( SERIAL_STATUS ) );
  217. DebugPrint(("InQueue = %d  OutQueue = %dn", deviceExtension->SerialStatus.AmountInInQueue, deviceExtension->SerialStatus.AmountInOutQueue ));
  218. KeReleaseSpinLock ( &deviceExtension->ThreadSpinLock, oldIrql );
  219. info = sizeof ( SERIAL_STATUS );
  220. status = STATUS_SUCCESS;
  221. break;
  222. }
  223. case IOCTL_SERIAL_GET_WAIT_MASK:
  224. {
  225. DebugPrint(("--  IOCTL_SERIAL_GET_WAIT_MASK   --n"));
  226. if( IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof( ULONG ) ){
  227. status = STATUS_BUFFER_TOO_SMALL;
  228. break;
  229. }
  230. *(PULONG)Irp->AssociatedIrp.SystemBuffer = deviceExtension->WaitMask;
  231. info = sizeof ( ULONG );
  232. status = STATUS_SUCCESS;
  233. break;
  234. }
  235. case IOCTL_SERIAL_GET_BAUD_RATE:
  236. {
  237. PSERIAL_BAUD_RATE Br = ( PSERIAL_BAUD_RATE )Irp->AssociatedIrp.SystemBuffer;
  238. DebugPrint(("--  IOCTL_SERIAL_GET_BAUD_RATE  ---n"));
  239. if( IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof( SERIAL_BAUD_RATE ) ){
  240. status = STATUS_BUFFER_TOO_SMALL;
  241. break;
  242. }
  243. Br->BaudRate = deviceExtension->CurrentBaud;
  244. DebugPrint(("CurrentBaud:  %d    Br->BaudRate   %dn", deviceExtension->CurrentBaud, Br->BaudRate ));
  245. info = sizeof( SERIAL_BAUD_RATE );
  246. status = STATUS_SUCCESS;
  247. break;
  248. }
  249. case IOCTL_SERIAL_SET_BAUD_RATE:
  250. DebugPrint(("--  IOCTL_SERIAL_SET_BAUD_RATE  ---n"));
  251. if( IrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof( SERIAL_BAUD_RATE ) ){
  252. status = STATUS_BUFFER_TOO_SMALL;
  253. break;
  254. }
  255. DebugPrint(("CurrentBaud :  %d     SetBaudRate:   %dn", deviceExtension->CurrentBaud, ((PSERIAL_BAUD_RATE)(Irp->AssociatedIrp.SystemBuffer))->BaudRate));
  256. deviceExtension->CurrentBaud = ((PSERIAL_BAUD_RATE)(Irp->AssociatedIrp.SystemBuffer))->BaudRate;
  257. status = STATUS_SUCCESS;
  258. break;
  259. case IOCTL_SERIAL_SET_LINE_CONTROL:
  260. {
  261. PSERIAL_LINE_CONTROL Lc;
  262. UCHAR LData;
  263. UCHAR LStop;
  264. UCHAR LParity;
  265. UCHAR Mask = 0xff;
  266. DebugPrint(("--  IOCTL_SERIAL_SET_LINE_CONTROL   --n"));
  267. if( IrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SERIAL_LINE_CONTROL)) {
  268. status = STATUS_BUFFER_TOO_SMALL;
  269. break;
  270. }
  271. Lc = ((PSERIAL_LINE_CONTROL)(Irp->AssociatedIrp.SystemBuffer));
  272. deviceExtension->LineControl.WordLength = Lc->WordLength;
  273. deviceExtension->LineControl.Parity = Lc->Parity;
  274. deviceExtension->LineControl.StopBits = Lc->StopBits;
  275. DebugPrint(("IOCTL_SERIAL_SET_LINE_CONTROL:  WordLength:  %d  Parity:  %d  StopBits  %dn", Lc->WordLength, Lc->Parity, Lc->StopBits ));
  276. status = STATUS_SUCCESS;
  277. break;
  279. }
  280. case IOCTL_SERIAL_GET_LINE_CONTROL:
  281. {
  282. PSERIAL_LINE_CONTROL Lc = (PSERIAL_LINE_CONTROL)Irp->AssociatedIrp.SystemBuffer;
  283. DebugPrint(("--  IOCTL_SERIAL_GET_LINE_CONTROL   --n"));
  285. if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_LINE_CONTROL)) {
  286. status = STATUS_BUFFER_TOO_SMALL;
  287. break;
  288. }
  289. Lc->WordLength = deviceExtension->LineControl.WordLength;
  290. Lc->Parity = deviceExtension->LineControl.Parity;
  291. Lc->StopBits = deviceExtension->LineControl.StopBits;
  293. DebugPrint(("IOCTL_SERIAL_GET_LINE_CONTROL:  WordLength:  %d  Parity:  %d  StopBits  %dn", Lc->WordLength, Lc->Parity, Lc->StopBits ));
  294. info = sizeof(SERIAL_LINE_CONTROL);
  295. status = STATUS_SUCCESS;
  296. break;
  297. }
  298. case IOCTL_SERIAL_SET_TIMEOUTS:
  299. {
  300. PSERIAL_TIMEOUTS NewTimeouts =
  301. ((PSERIAL_TIMEOUTS)(Irp->AssociatedIrp.SystemBuffer));
  302. DebugPrint(("--  IOCTL_SERIAL_SET_TIMEOUTS   --n"));
  303. if ( IrpStack->Parameters.DeviceIoControl.InputBufferLength <
  304. sizeof(SERIAL_TIMEOUTS)) {
  305. status = STATUS_BUFFER_TOO_SMALL;
  306. break;
  307. }
  308. if ((NewTimeouts->ReadIntervalTimeout == MAXULONG) &&
  309. (NewTimeouts->ReadTotalTimeoutMultiplier == MAXULONG) &&
  310. (NewTimeouts->ReadTotalTimeoutConstant == MAXULONG)) {
  311. status = STATUS_INVALID_PARAMETER;
  312. break;
  313. }
  314. deviceExtension->Timeouts.ReadIntervalTimeout = NewTimeouts->ReadIntervalTimeout;
  315. deviceExtension->Timeouts.ReadTotalTimeoutMultiplier =NewTimeouts->ReadTotalTimeoutMultiplier;
  316. deviceExtension->Timeouts.ReadTotalTimeoutConstant = NewTimeouts->ReadTotalTimeoutConstant;
  317. deviceExtension->Timeouts.WriteTotalTimeoutMultiplier = NewTimeouts->WriteTotalTimeoutMultiplier;
  318. deviceExtension->Timeouts.WriteTotalTimeoutConstant = NewTimeouts->WriteTotalTimeoutConstant;
  319. DebugPrint(("Set_Timeoutsn"));
  320. status = STATUS_SUCCESS;
  321. break;
  322. }
  323. case IOCTL_SERIAL_GET_TIMEOUTS:
  324. {
  325. if ( IrpStack->Parameters.DeviceIoControl.OutputBufferLength <
  326. sizeof(SERIAL_TIMEOUTS)) {
  327. status = STATUS_BUFFER_TOO_SMALL;
  328. break;
  329. }
  330. DebugPrint(("--  IOCTL_SERIAL_GET_TIMEOUTS   --n"));
  331. *((PSERIAL_TIMEOUTS)Irp->AssociatedIrp.SystemBuffer) = deviceExtension->Timeouts;
  332. info = sizeof( SERIAL_TIMEOUTS );
  333. status = STATUS_SUCCESS;
  334. break;
  335. }
  336. case IOCTL_SERIAL_SET_CHARS:
  337. {
  338. PSERIAL_CHARS NewChars =
  339. ((PSERIAL_CHARS)(Irp->AssociatedIrp.SystemBuffer));
  340. DebugPrint(("--  IOCTL_SERIAL_SET_CHARS   --n"));
  341. if ( IrpStack->Parameters.DeviceIoControl.InputBufferLength <
  342. ( sizeof( UCHAR ) * 6 ) ) {
  343. status = STATUS_BUFFER_TOO_SMALL;
  344. break;
  345. }else /*if( NewChars->XonChar == NewChars->XoffChar ){
  346. status = STATUS_INVALID_PARAMETER;
  347. break;
  348. }else */{
  349. deviceExtension->SpecialChars.EofChar = NewChars->EofChar;
  350. deviceExtension->SpecialChars.ErrorChar = NewChars->ErrorChar;
  351. deviceExtension->SpecialChars.BreakChar = NewChars->BreakChar;
  352. deviceExtension->SpecialChars.EventChar = NewChars->EventChar;
  353. deviceExtension->SpecialChars.XonChar = NewChars->XonChar;
  354. deviceExtension->SpecialChars.XoffChar = NewChars->XoffChar;
  355. DebugPrint(("SetChars:  %2x %2x %2x %2x %2x %2xn", NewChars->EofChar, NewChars->ErrorChar, NewChars->BreakChar, NewChars->EventChar, NewChars->XonChar, NewChars->XoffChar ));
  356. status = STATUS_SUCCESS;
  357. }
  358. break;
  359. }
  360. case IOCTL_SERIAL_GET_CHARS:
  361. {
  362. PSERIAL_CHARS NewChars = ((PSERIAL_CHARS)(Irp->AssociatedIrp.SystemBuffer));
  363. DebugPrint(("--  IOCTL_SERIAL_GET_CHARS   --n"));
  365. if( IrpStack->Parameters.DeviceIoControl.OutputBufferLength <
  366. sizeof(SERIAL_CHARS)) {
  367. status = STATUS_BUFFER_TOO_SMALL;
  368. break;
  369. }
  370. ((PSERIAL_CHARS)Irp->AssociatedIrp.SystemBuffer)->XonChar = deviceExtension->SpecialChars.XonChar;
  371. ((PSERIAL_CHARS)Irp->AssociatedIrp.SystemBuffer)->XoffChar = deviceExtension->SpecialChars.XoffChar;
  372. ((PSERIAL_CHARS)Irp->AssociatedIrp.SystemBuffer)->EofChar = deviceExtension->SpecialChars.EofChar;
  373. ((PSERIAL_CHARS)Irp->AssociatedIrp.SystemBuffer)->ErrorChar = deviceExtension->SpecialChars.ErrorChar;
  374. ((PSERIAL_CHARS)Irp->AssociatedIrp.SystemBuffer)->BreakChar = deviceExtension->SpecialChars.BreakChar;
  375. ((PSERIAL_CHARS)Irp->AssociatedIrp.SystemBuffer)->EventChar = deviceExtension->SpecialChars.EventChar;
  376. DebugPrint(("GetChars:  %2x %2x %2x %2x %2x %2xn", NewChars->EofChar, NewChars->ErrorChar, NewChars->BreakChar, NewChars->EventChar, NewChars->XonChar, NewChars->XoffChar ));
  377. info = sizeof( SERIAL_CHARS );
  378. status = STATUS_SUCCESS;
  379. break;
  380. }
  381. case IOCTL_SERIAL_SET_DTR:
  382. {
  383. DebugPrint(("--  IOCTL_SERIAL_SET_DTR   --n"));
  384. if (( deviceExtension->HandFlow.ControlHandShake & SERIAL_DTR_MASK) == SERIAL_DTR_HANDSHAKE){
  385. DebugPrint(("IOCTL_SERIAL_SET_DTR error: Current ControlHandShake 0x%xn", deviceExtension->HandFlow.ControlHandShake ));
  386. status = STATUS_INVALID_PARAMETER;
  387. }
  388. info = 0;
  389. //*(PULONG)Irp->AssociatedIrp.SystemBuffer = 0;
  390. status = STATUS_SUCCESS;
  391. break;
  392. }
  393.         case IOCTL_SERIAL_CLR_DTR:
  394. {
  395. DebugPrint(("--  IOCTL_SERIAL_CLR_DTR   --n"));
  396. if (( deviceExtension->HandFlow.ControlHandShake & SERIAL_DTR_MASK) == SERIAL_DTR_HANDSHAKE){
  397. DebugPrint(("IOCTL_SERIAL_CLR_DTR errorn"));
  398. status = STATUS_INVALID_PARAMETER;
  399. }
  400. //*(PULONG)Irp->AssociatedIrp.SystemBuffer = 0;
  401. status = STATUS_SUCCESS;
  402. break;
  403. }
  404. case IOCTL_SERIAL_SET_RTS:
  405. {
  406. DebugPrint(("--  IOCTL_SERIAL_SET_RTS   --n"));
  407. if (( deviceExtension->HandFlow.FlowReplace & SERIAL_RTS_MASK) == SERIAL_RTS_HANDSHAKE ){
  408. DebugPrint(("IOCTL_SERIAL_SET_RTS errorn"));
  409. status = STATUS_INVALID_PARAMETER;
  410. }
  411. status = STATUS_SUCCESS;
  412. break;
  413. }
  415. case IOCTL_SERIAL_SET_QUEUE_SIZE:
  416. {
  417. PSERIAL_QUEUE_SIZE Rs = ( PSERIAL_QUEUE_SIZE )Irp->AssociatedIrp.SystemBuffer;
  418. DebugPrint(("--  IOCTL_SERIAL_SET_QUEUE_SIZE   --n"));
  419. if( IrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SERIAL_QUEUE_SIZE)) {
  420. status = STATUS_BUFFER_TOO_SMALL;
  421. break;
  422. }
  423. if( Rs->InSize > deviceExtension->BufferSize ){
  424. deviceExtension->BufferSize = Rs->InSize;
  425. }
  426. DebugPrint(("Buffersize :  %dn", deviceExtension->BufferSize ));
  427. status = STATUS_SUCCESS;
  428. break;
  429. }
  430. case IOCTL_SERIAL_GET_HANDFLOW:
  431. {
  432. PSERIAL_HANDFLOW HandFlow;
  433. DebugPrint(("--  IOCTL_SERIAL_GET_HANDFLOW   --n"));
  434. if ( IrpStack->Parameters.DeviceIoControl.OutputBufferLength <
  435. sizeof(SERIAL_HANDFLOW)) {
  436. status = STATUS_BUFFER_TOO_SMALL;
  437. break;
  438. }
  439. HandFlow = (PSERIAL_HANDFLOW)Irp->AssociatedIrp.SystemBuffer;
  440. HandFlow->ControlHandShake = deviceExtension->HandFlow.ControlHandShake;
  441. HandFlow->FlowReplace = deviceExtension->HandFlow.FlowReplace;
  442. HandFlow->XonLimit = deviceExtension->HandFlow.XonLimit;
  443. HandFlow->XoffLimit = deviceExtension->HandFlow.XoffLimit;
  444. DebugPrint(("ControlHandShake:  %d  FlowReplace:  %d  XonLimit:  %d  XoffLimit:  %dn", HandFlow->ControlHandShake, HandFlow->FlowReplace, HandFlow->XonLimit, HandFlow->XoffLimit));
  445. info = sizeof(SERIAL_HANDFLOW);
  446. status = STATUS_SUCCESS;
  447. break;
  448. }
  449. case IOCTL_SERIAL_SET_HANDFLOW:
  450. {
  451.             PSERIAL_HANDFLOW HandFlow = Irp->AssociatedIrp.SystemBuffer;
  452. if ( IrpStack->Parameters.DeviceIoControl.InputBufferLength <
  453. sizeof(SERIAL_HANDFLOW)) {
  454. status = STATUS_BUFFER_TOO_SMALL;
  455. break;
  456. }
  457. DebugPrint(("--  IOCTL_SERIAL_SET_HANDFLOW   --n"));
  459. if (HandFlow->ControlHandShake & SERIAL_CONTROL_INVALID) {
  460. status = STATUS_INVALID_PARAMETER;
  461. break;
  462. }
  463. if (HandFlow->FlowReplace & SERIAL_FLOW_INVALID) {
  464. status = STATUS_INVALID_PARAMETER;
  465. break;
  466. }
  467. if ((HandFlow->ControlHandShake & SERIAL_DTR_MASK) ==
  468. SERIAL_DTR_MASK) {
  469. status = STATUS_INVALID_PARAMETER;
  470. break;
  471. }
  472. if ((HandFlow->XonLimit < 0) ||
  473. ((ULONG)HandFlow->XonLimit > deviceExtension->BufferSize)) {
  474. DebugPrint(("XonLimit( %d ) > BufferSizen", ((ULONG)HandFlow->XonLimit )));
  475. status = STATUS_INVALID_PARAMETER;
  476. break;
  477. }
  478. if ((HandFlow->XoffLimit < 0) ||
  479. ((ULONG)HandFlow->XoffLimit > deviceExtension->BufferSize)) {
  480. DebugPrint(("XoffLimit( %d ) > BufferSizen", ((ULONG)HandFlow->XoffLimit )));
  481. status = STATUS_INVALID_PARAMETER;
  482. break;
  483. }
  484. deviceExtension->HandFlow.ControlHandShake = HandFlow->ControlHandShake;
  485. deviceExtension->HandFlow.FlowReplace = HandFlow->FlowReplace;
  486. deviceExtension->HandFlow.XonLimit = HandFlow->XonLimit;
  487. deviceExtension->HandFlow.XoffLimit = HandFlow->XoffLimit;
  488. DebugPrint(("Set_HandFlow OKn"));
  489. status = STATUS_SUCCESS;
  490. break;
  491. }
  493. case IOCTL_SERIAL_CONFIG_SIZE:
  494. {
  495. DebugPrint(("--  IOCTL_SERIAL_CONFIG_SIZE   --n"));
  496. if( IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof( ULONG ) ){
  497. status = STATUS_BUFFER_TOO_SMALL;
  498. break;
  499. }
  501. info = sizeof( ULONG );
  502. *(PULONG)Irp->AssociatedIrp.SystemBuffer = 0;
  503. status = STATUS_SUCCESS;
  504. break;
  505. }
  507. case IOCTL_SERIAL_IMMEDIATE_CHAR:
  508. DebugPrint(("--  IOCTL_SERIAL_IMMEDIATE_CHAR   --n"));
  509. break;
  510. case IOCTL_SERIAL_GET_STATS:
  511. DebugPrint(("--  IOCTL_SERIAL_GET_STATS   --n"));
  512. break;
  513. case IOCTL_SERIAL_CLEAR_STATS:
  514. DebugPrint(("--  IOCTL_SERIAL_CLEAR_STATS   --n"));
  515. break;
  516. case IOCTL_SERIAL_GET_PROPERTIES:
  517. DebugPrint(("--  IOCTL_SERIAL_GET_PROPERTIES   --n"));
  518. break;
  519. case IOCTL_SERIAL_XOFF_COUNTER:
  520. DebugPrint(("--  IOCTL_SERIAL_XOFF_COUNTER   --n"));
  521. break;
  522. case IOCTL_SERIAL_LSRMST_INSERT:
  523. DebugPrint(("--  IOCTL_SERIAL_LSRMST_INSERT   --n"));
  524. break;
  525. case IOCTL_SERIAL_GET_MODEMSTATUS:
  526. DebugPrint(("--  IOCTL_SERIAL_GET_MODEMSTATUS   --n"));
  527. break;
  528. case IOCTL_SERIAL_GET_DTRRTS:
  529. DebugPrint(("--  IOCTL_SERIAL_GET_DTRRTS   --n"));
  530. break;
  531. case IOCTL_SERIAL_CLR_RTS:
  532. DebugPrint(("--  IOCTL_SERIAL_CLR_RTS   --n"));
  533. break;
  534. case IOCTL_SERIAL_SET_XOFF:
  535. DebugPrint(("--  IOCTL_SERIAL_SET_XOFF   --n"));
  536. break;
  537. case IOCTL_SERIAL_SET_XON:
  538. DebugPrint(("--  IOCTL_SERIAL_SET_XON   --n"));
  539. break;
  540. case IOCTL_SERIAL_SET_BREAK_ON:
  541. DebugPrint(("--  IOCTL_SERIAL_SET_BREAK_ON   --n"));
  542. break;
  543. case IOCTL_SERIAL_SET_BREAK_OFF:
  544. DebugPrint(("--  IOCTL_SERIAL_SET_BREAK_OFF   --n"));
  545. break;
  546. case IOCTL_SERIAL_RESET_DEVICE:
  547. DebugPrint(("--  IOCTL_SERIAL_RESET_DEVICE   --n"));
  548. break;
  549. case IOCTL_SERIAL_GET_MODEM_CONTROL:
  550. DebugPrint(("--  IOCTL_SERIAL_GET_MODEM_CONTROL   --n"));
  551. break;
  552. case IOCTL_SERIAL_SET_MODEM_CONTROL:
  553. DebugPrint(("--  IOCTL_SERIAL_SET_MODEM_CONTROL   --n"));
  554. break;
  555. case IOCTL_SERIAL_SET_FIFO_CONTROL:
  556. DebugPrint(("--  IOCTL_SERIAL_SET_FIFO_CONTROL   --n"));
  557. break;
  558. default:
  559. status=STATUS_INVALID_DEVICE_REQUEST;
  560. break;
  561. }
  562. status = CompleteRequest( Irp, status, info );
  564.     SampleIoDecrement( deviceExtension );
  566. return status;
  567. }
  568. NTSTATUS CreateDosName( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
  569. /*++
  571. Routine Description:
  573. Create Dosname.
  575. Arguments:
  577.    DeviceObject - pointer to a device object.
  579.    Irp - pointer to an I/O Request Packet.
  581. Return Value:
  583.       NT status code
  585. --*/
  586. {
  587. LONG ComX;
  588. PIO_STACK_LOCATION IrpStack;
  589. NTSTATUS status;
  590. PDEVICE_EXTENSION deviceExtension;
  592. deviceExtension = DeviceObject->DeviceExtension;
  594. DebugPrint(("-----  IOCTL_INIT_SETTING   ----n"));
  595. IrpStack = IoGetCurrentIrpStackLocation(Irp);
  597. if( IrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof( LONG ) ){
  598. status = STATUS_BUFFER_TOO_SMALL;
  599. return status;
  600. }
  601. ComX = *((PLONG)Irp->AssociatedIrp.SystemBuffer);
  602. // 此处注意Dos名不要重复
  603. if( ( ComX > 255 ) || ( ComX < 1 ) ){
  604. status = STATUS_INVALID_PARAMETER;
  605. return status;
  606. }
  607. if( !deviceExtension->CreatedSymbolicLink ){
  608. status = SerialDoExternalNaming( deviceExtension, ComX);
  609. }
  610. return status;
  611. }