纳闷了N天的一个菜鸟驱动问题

gfrsmall 2010-04-30 11:27:26
怎么能使以下编译通过,就是想把这个NdisMSleep(1)加下去就是找不到头文件
纳闷了N天了......我是新手请各位路过的大哥帮下小弟....!!!

//////////////////////////////////////////////////
// a.cpp文件

#define NDIS50 1

extern "C"
{
#include <ntddk.h>
#include <ndis.h>
}

#pragma comment(lib,"ndis")

// 驱动程序加载时调用DriverEntry例程
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
{
NdisMSleep(1);
// 请视情况返回DriverEntry例程执行结果
return STATUS_DEVICE_CONFIGURATION_ERROR;
}


编译时错误如下,还有加NdisMRegisterDevice这类中间层函数都是同样报错,但加协议驱动的函数没问题
是缺少了什么头文件?找了N天了还是搞不懂!!!
--------------------Configuration: a - Win32 Debug--------------------
Compiling...
a.cpp
E:\vc_code\a\a.cpp(17) : error C2065: 'NdisMSleep' : undeclared identifier
Error executing cl.exe.

a.sys - 1 error(s), 0 warning(s)

但在ndis.h中找到了这个函数的定义如下
EXPORT
VOID
NdisMSleep(
IN ULONG MicrosecondsToSleep
);
...全文
359 9 打赏 收藏 转发到动态 举报
写回复
用AI写文章
9 条回复
切换为时间正序
请发表友善的回复…
发表回复
hanshuo2010 2010-09-17
  • 打赏
  • 举报
 回复
你试试把VC6.0编译环境的DDK路径提前到6.0自己的库前面再编译
gfrsmall 2010-05-01
  • 打赏
  • 举报
 回复

VOID
ProtocolTransferDataComplete (IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET pPacket,
IN NDIS_STATUS Status,
IN UINT BytesTransfered)
{
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
PMDL pMdl = RESERVED(pPacket)->pMdl;
PIRP pIrp = RESERVED(pPacket)->pIrp;
if(pMdl != NULL)
IoFreeMdl(pMdl);
NdisFreePacket(pPacket);
if(Status == NDIS_STATUS_SUCCESS)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
pIrp->IoStatus.Information = BytesTransfered + ETHERNET_HEADER_LENGTH;
}
else
{
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
pIrp->IoStatus.Information = 0;
}
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}


VOID
ProtocolReceiveComplete(IN NDIS_HANDLE ProtocolBindingContext)
{
}

/*
int ProtocolReceivePacket(NDIS_HANDLE ProtocolBindingContext, PNDIS_PACKET Packet)
{
DbgPrint("ProtocolReceivePacket \n");
UINT nBufferLen;
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
PLIST_ENTRY pListEntry = ExInterlockedRemoveHeadList(&pOpen->RcvList, &pOpen->RcvSpinLock);
if(pListEntry == NULL)
{
return 0;
}
PACKET_RESERVED *pReserved = CONTAINING_RECORD(pListEntry, PACKET_RESERVED, ListElement);
NDIS_PACKET *pPacket = CONTAINING_RECORD(pReserved, NDIS_PACKET, ProtocolReserved);
PIRP pIrp = RESERVED(pPacket)->pIrp;
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
IoSetCancelRoutine(pIrp, NULL);
NTSTATUS status = STATUS_SUCCESS;
{
PNDIS_BUFFER firstBuffer, nextBuffer;
UINT totalLength;
PVOID virtualAddress;
NdisQueryPacket(pPacket, NULL, NULL, &firstBuffer, &totalLength);
while(firstBuffer != NULL)
{
NdisQueryBufferSafe(firstBuffer, &virtualAddress, &totalLength, NormalPagePriority);
if(virtualAddress == NULL)
{
status = STATUS_INSUFFICIENT_RESOURCES;
goto CleanExit;
}
NdisGetNextBuffer(firstBuffer, &nextBuffer);
firstBuffer = nextBuffer;
}
}
NdisChainBufferAtFront(pPacket, pIrp->MdlAddress);
nBufferLen = pIrpSp->Parameters.Read.Length;
UINT nTransfered;
NdisCopyFromPacketToPacket(pPacket, 0, nBufferLen,Packet,0,&nTransfered);
CleanExit:
pIrp->IoStatus.Information = nTransfered;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
return 0;
}
*/

NTSTATUS DispatchWrite(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
NTSTATUS status;
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)pDevObj->DeviceExtension;
IoIncrement(pOpen);
do
{
if(!pOpen->bBound)
{
status = STATUS_DEVICE_NOT_READY;
break;
}
PNDIS_PACKET pPacket;
NdisAllocatePacket((NDIS_STATUS*)&status, &pPacket, pOpen->hPacketPool);
if(status != NDIS_STATUS_SUCCESS)
{
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RESERVED(pPacket)->pIrp = pIrp;
NdisChainBufferAtFront(pPacket, pIrp->MdlAddress);
IoMarkIrpPending(pIrp);
NdisSend((NDIS_STATUS*)&status, pOpen->hAdapter, pPacket);
if(status != NDIS_STATUS_PENDING)
{
ProtocolSendComplete(pOpen, pPacket, status);
}
return STATUS_PENDING;
}while(FALSE);
if(status != STATUS_SUCCESS)
{
IoDecrement(pOpen);
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
return status;
}


VOID
ProtocolSendComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET pPacket,
IN NDIS_STATUS Status)
{
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
PIRP pIrp = RESERVED(pPacket)->pIrp;
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
NdisFreePacket(pPacket);
if(Status == NDIS_STATUS_SUCCESS)
{
pIrp->IoStatus.Information = pIrpSp->Parameters.Write.Length;
pIrp->IoStatus.Status = STATUS_SUCCESS;
DbgPrint(" ProtoDrv: Send data success \n");
}
else
{
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
}
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}

怎么协议驱动能编译怎么就是写中间层驱动的函数就不行的呢是VC6.0+win2000ddk怎么配环境变量?
gfrsmall 2010-05-01
  • 打赏
  • 举报
 回复

VOID
ProtocolOpenAdapterComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status,
IN NDIS_STATUS OpenErrorStatus)
{
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)ProtocolBindingContext;
pOpen->Status = Status;
NdisSetEvent(&pOpen->BindEvent);
}

VOID
ProtocolUnbindAdapter(OUT PNDIS_STATUS Status,
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE UnbindContext)
{
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
if(pOpen->hAdapter != NULL)
{
NdisResetEvent(&pOpen->BindEvent);
InterlockedExchange((PLONG)&pOpen->bBound, FALSE);
CancelReadIrp(pOpen->pDeviceObj);
NdisWaitEvent(&pOpen->CleanupEvent, 0);
NdisCloseAdapter(Status, pOpen->hAdapter);
if(*Status == NDIS_STATUS_PENDING)
{
NdisWaitEvent(&pOpen->BindEvent, 0);
*Status = pOpen->Status;
}
else
{
*Status = NDIS_STATUS_FAILURE;
}
KIRQL oldIrql;
KeAcquireSpinLock(&g_data.GlobalLock, &oldIrql);
RemoveEntryList(&pOpen->AdapterListEntry);
KeReleaseSpinLock(&g_data.GlobalLock, oldIrql);
NdisFreePacketPool(pOpen->hPacketPool);
NdisFreeMemory(pOpen->ustrAdapterName.Buffer, pOpen->ustrAdapterName.Length, 0);
IoDeleteSymbolicLink(&pOpen->ustrLinkName);
ExFreePool(pOpen->ustrLinkName.Buffer);
IoDeleteDevice(pOpen->pDeviceObj);
}
}

VOID
ProtocolCloseAdapterComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status)
{
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)ProtocolBindingContext;
pOpen->Status = Status;
NdisSetEvent(&pOpen->BindEvent);
}

NTSTATUS DispatchRead(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
NTSTATUS status = STATUS_SUCCESS;
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)pDevObj->DeviceExtension;
IoIncrement(pOpen);
do
{
if(!pOpen->bBound)
{
status = STATUS_DEVICE_NOT_READY;
break;
}
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(pIrp);
if(irpSp->Parameters.Read.Length < ETHERNET_HEADER_LENGTH)
{
status = STATUS_BUFFER_TOO_SMALL;
break;
}
PNDIS_PACKET pPacket;
NdisAllocatePacket((PNDIS_STATUS)&status, &pPacket, pOpen->hPacketPool);
if(status != NDIS_STATUS_SUCCESS)
{
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RESERVED(pPacket)->pIrp = pIrp;
RESERVED(pPacket)->pMdl = NULL;
IoMarkIrpPending(pIrp);
IoSetCancelRoutine(pIrp, ReadCancelRoutine);
ExInterlockedInsertTailList(&pOpen->RcvList,
&RESERVED(pPacket)->ListElement, &pOpen->RcvSpinLock);
return STATUS_PENDING;
}while(FALSE);
if(status != STATUS_SUCCESS)
{
IoDecrement(pOpen);
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
return status;
}

VOID
ReadCancelRoutine (IN PDEVICE_OBJECT pDeviceObject,
IN PIRP pIrp)
{
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)pDeviceObject->DeviceExtension;
NDIS_PACKET *pPacket = NULL;
KIRQL oldIrql = pIrp->CancelIrql;
KeAcquireSpinLockAtDpcLevel(&pOpen->RcvSpinLock);
IoReleaseCancelSpinLock(KeGetCurrentIrql());
PLIST_ENTRY pThisEntry = NULL;
PACKET_RESERVED *pReserved;
PLIST_ENTRY pHead = &pOpen->RcvList;
for(pThisEntry = pHead->Flink; pThisEntry != pHead; pThisEntry = pThisEntry->Flink)
{
pReserved = CONTAINING_RECORD(pThisEntry, PACKET_RESERVED, ListElement);
if(pReserved->pIrp == pIrp)
{
RemoveEntryList(pThisEntry);
pPacket = CONTAINING_RECORD(pReserved, NDIS_PACKET, ProtocolReserved);
break;
}
}
KeReleaseSpinLock(&pOpen->RcvSpinLock, oldIrql);
if(pPacket != NULL)
{
NdisFreePacket(pPacket);
pIrp->IoStatus.Status = STATUS_CANCELLED;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}
}

void CancelReadIrp(PDEVICE_OBJECT pDeviceObj)
{
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)pDeviceObj->DeviceExtension;
PLIST_ENTRY thisEntry;
PACKET_RESERVED *reserved;
PNDIS_PACKET myPacket;
PIRP pPendingIrp;
while(thisEntry = ExInterlockedRemoveHeadList(&pOpen->RcvList, &pOpen->RcvSpinLock))
{
reserved = CONTAINING_RECORD(thisEntry, PACKET_RESERVED, ListElement);
myPacket = CONTAINING_RECORD(reserved, NDIS_PACKET, ProtocolReserved);
pPendingIrp = RESERVED(myPacket)->pIrp;
NdisFreePacket(myPacket);
IoSetCancelRoutine(pPendingIrp, NULL);
pPendingIrp->IoStatus.Information = 0;
pPendingIrp->IoStatus.Status = STATUS_CANCELLED;
IoCompleteRequest(pPendingIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}
}

NDIS_STATUS
ProtocolReceive(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookAheadBuffer,
IN UINT LookaheadBufferSize,
IN UINT PacketSize)
{
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
if(HeaderBufferSize > ETHERNET_HEADER_LENGTH)
{
return NDIS_STATUS_SUCCESS;
}
PLIST_ENTRY pListEntry = ExInterlockedRemoveHeadList(&pOpen->RcvList, &pOpen->RcvSpinLock);
if(pListEntry == NULL)
{
return NDIS_STATUS_NOT_ACCEPTED;
}
PACKET_RESERVED *pReserved = CONTAINING_RECORD(pListEntry, PACKET_RESERVED, ListElement);
NDIS_PACKET *pPacket = CONTAINING_RECORD(pReserved, NDIS_PACKET, ProtocolReserved);
PIRP pIrp = RESERVED(pPacket)->pIrp;
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
IoSetCancelRoutine(pIrp, NULL);
NdisMoveMappedMemory(MmGetSystemAddressForMdlSafe(pIrp->MdlAddress, NormalPagePriority),
HeaderBuffer, HeaderBufferSize);
UINT nBufferLen = pIrpSp->Parameters.Read.Length - HeaderBufferSize;
UINT nSizeToTransfer = nBufferLen < LookaheadBufferSize ? nBufferLen : LookaheadBufferSize;
NDIS_STATUS status;
PMDL pMdl = IoAllocateMdl(MmGetMdlVirtualAddress(pIrp->MdlAddress),
MmGetMdlByteCount(pIrp->MdlAddress), FALSE, FALSE, NULL);
if(pMdl == NULL)
{
status = NDIS_STATUS_RESOURCES;
goto ERROR;
}
IoBuildPartialMdl(
pIrp->MdlAddress,
pMdl,
((PUCHAR)MmGetMdlVirtualAddress(pIrp->MdlAddress)) + ETHERNET_HEADER_LENGTH,
0
);
pMdl->Next=NULL;
RESERVED(pPacket)->pMdl = pMdl;
NdisChainBufferAtFront(pPacket,pMdl);
UINT nBytesTransfered;
NdisTransferData(&status,
pOpen->hAdapter,
MacReceiveContext,
0,
nSizeToTransfer,
pPacket,
&nBytesTransfered);
if(status == NDIS_STATUS_PENDING)
{
return NDIS_STATUS_SUCCESS;
}
ERROR:
ProtocolTransferDataComplete(pOpen,
pPacket,
status,
nBytesTransfered);
return NDIS_STATUS_SUCCESS;
}
gfrsmall 2010-05-01
  • 打赏
  • 举报
 回复

VOID
ProtocolResetComplete(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status
)

{
OPEN_INSTANCE *pOpen;
pOpen = (OPEN_INSTANCE*)ProtocolBindingContext;
PLIST_ENTRY pListEntry = ExInterlockedRemoveHeadList(&pOpen->ResetIrpList,
&pOpen->ResetQueueLock);
PIRP pIrp = CONTAINING_RECORD(pListEntry,IRP,Tail.Overlay.ListEntry);
if(Status == NDIS_STATUS_SUCCESS)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
}
else
{
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
}
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}

VOID
ProtocolRequestComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_REQUEST NdisRequest,
IN NDIS_STATUS Status)
{
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)ProtocolBindingContext;
PINTERNAL_REQUEST pInterRequest = CONTAINING_RECORD(NdisRequest, INTERNAL_REQUEST, Request);
PIRP pIrp = pInterRequest->pIrp;
if(Status == NDIS_STATUS_SUCCESS)
{
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
UINT nIoControlCode = pIrpSp->Parameters.DeviceIoControl.IoControlCode;
PPROTOCOL_OID_DATA pOidData = (PPROTOCOL_OID_DATA)pIrp->AssociatedIrp.SystemBuffer;
if(nIoControlCode == IOCTL_PROTOCOL_SET_OID)
{
pOidData->Length = pInterRequest->Request.DATA.SET_INFORMATION.BytesRead;
}
else if(nIoControlCode == IOCTL_PROTOCOL_QUERY_OID)
{
pOidData->Length = pInterRequest->Request.DATA.QUERY_INFORMATION.BytesWritten;
}
pIrp->IoStatus.Information = pIrpSp->Parameters.DeviceIoControl.InputBufferLength;
pIrp->IoStatus.Status = STATUS_SUCCESS;
}
else
{
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
}
ExFreePool(pInterRequest);
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}

NTSTATUS
GetAdapterList(IN PVOID Buffer,
IN ULONG Length,
IN OUT PULONG DataLength)
{
KIRQL oldIrql;
KeAcquireSpinLock(&g_data.GlobalLock, &oldIrql);
OPEN_INSTANCE *pOpen ;
ULONG nRequiredLength = 0;
ULONG nAdapters = 0;
PLIST_ENTRY pThisEntry;
PLIST_ENTRY pHeader = &g_data.AdapterList;
for(pThisEntry = pHeader->Flink ; pThisEntry != pHeader; pThisEntry = pThisEntry->Flink)
{
pOpen = CONTAINING_RECORD(pThisEntry, OPEN_INSTANCE, AdapterListEntry);
nRequiredLength += pOpen->ustrAdapterName.Length + sizeof(UNICODE_NULL);
nRequiredLength += pOpen->ustrLinkName.Length + sizeof(UNICODE_NULL);
nAdapters++;
}
nRequiredLength += sizeof(nAdapters) + sizeof(UNICODE_NULL);
*DataLength = nRequiredLength;
if(nRequiredLength > Length)
{
KeReleaseSpinLock(&g_data.GlobalLock, oldIrql);
return STATUS_BUFFER_TOO_SMALL;
}
*(PULONG)Buffer = nAdapters;
Buffer = (PCHAR)Buffer + sizeof(ULONG);
for(pThisEntry = pHeader->Flink;
pThisEntry != pHeader;
pThisEntry = pThisEntry->Flink)
{
pOpen = CONTAINING_RECORD(pThisEntry, OPEN_INSTANCE, AdapterListEntry);
RtlCopyMemory(Buffer, pOpen->ustrAdapterName.Buffer,
pOpen->ustrAdapterName.Length + sizeof(WCHAR));
Buffer = (PCHAR)Buffer + pOpen->ustrAdapterName.Length + sizeof(WCHAR);
RtlCopyMemory(Buffer, pOpen->ustrLinkName.Buffer,
pOpen->ustrLinkName.Length + sizeof(WCHAR));
Buffer = (PCHAR)Buffer + pOpen->ustrLinkName.Length + sizeof(WCHAR);
}
*(PWCHAR)Buffer = UNICODE_NULL;
KeReleaseSpinLock(&g_data.GlobalLock, oldIrql);
return STATUS_SUCCESS;
}

void IoIncrement(OPEN_INSTANCE *pOpen)
{
if(InterlockedIncrement((PLONG)&pOpen->nIrpCount) == 1)
NdisResetEvent(&pOpen->CleanupEvent);
}

void IoDecrement(OPEN_INSTANCE *pOpen)
{
if(InterlockedDecrement((PLONG)&pOpen->nIrpCount) == 0)
NdisSetEvent(&pOpen->CleanupEvent);
}

NTSTATUS
DispatchCleanup(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)DeviceObject->DeviceExtension;
NTSTATUS status = STATUS_SUCCESS;
if(DeviceObject == g_data.pControlDevice)
{
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
}
IoIncrement(pOpen);
CancelReadIrp(DeviceObject);
IoDecrement(pOpen);
NdisWaitEvent(&pOpen->CleanupEvent, 0);
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = status;
IoCompleteRequest (Irp, IO_NO_INCREMENT);
return status;
}


VOID
ProtocolStatus(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status,
IN PVOID StatusBuffer,
IN UINT StatusBufferSize)
{
}

VOID
ProtocolStatusComplete(IN NDIS_HANDLE ProtocolBindingContext)
{
}

NDIS_STATUS
ProtocolPNPHandler(IN NDIS_HANDLE ProtocolBindingContext,
IN PNET_PNP_EVENT NetPnPEvent)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PNET_DEVICE_POWER_STATE powerState;
powerState = (PNET_DEVICE_POWER_STATE)NetPnPEvent->Buffer;
switch(NetPnPEvent->NetEvent)
{
case NetEventSetPower :
switch (*powerState)
{
case NetDeviceStateD0:
Status = NDIS_STATUS_SUCCESS;
break;
default:
Status = NDIS_STATUS_NOT_SUPPORTED;
break;
}
}
return Status;
}

VOID
ProtocolBindAdapter(OUT PNDIS_STATUS Status,
IN NDIS_HANDLE BindContext,
IN PNDIS_STRING DeviceName,
IN PVOID SystemSpecific1,
IN PVOID SystemSpecific2)
{

DbgPrint(" ProtoDrv: ProtocolBindAdapter... \n");
NDIS_STATUS status = STATUS_SUCCESS;
PDEVICE_OBJECT pDeviceObj = NULL;
UNICODE_STRING ustrDevName = { 0 };
OPEN_INSTANCE *pOpen = NULL;
do
{
int nLen = DeviceName->Length + 7*sizeof(WCHAR) + sizeof(UNICODE_NULL);
PWSTR strName = (PWSTR)ExAllocatePool(NonPagedPool, nLen);
if(strName == NULL)
{
*Status = NDIS_STATUS_FAILURE;
break;
}
swprintf(strName, L"\\Device\\Packet_%ws", &DeviceName->Buffer[8]);
RtlInitUnicodeString(&ustrDevName, strName);
status = IoCreateDevice(g_data.pDriverObj,
sizeof(OPEN_INSTANCE),
&ustrDevName,
FILE_DEVICE_PROTOCOL,
0,
TRUE,
&pDeviceObj);
if(status != STATUS_SUCCESS)
{
DbgPrint(" ProtoDrv: CreateDevice() failed \n ");
*Status = NDIS_STATUS_FAILURE;
break;
}
pDeviceObj->Flags |= DO_DIRECT_IO;
pOpen = (OPEN_INSTANCE*)pDeviceObj->DeviceExtension;
pOpen->pDeviceObj = pDeviceObj;
nLen = ustrDevName.Length + 4*sizeof(WCHAR) + sizeof(UNICODE_NULL);
strName = (PWSTR)ExAllocatePool(NonPagedPool, nLen);
if(strName == NULL)
{
*Status = NDIS_STATUS_FAILURE;
break;
}
swprintf(strName, L"\\DosDevices\\%ws", &ustrDevName.Buffer[8]);
RtlInitUnicodeString(&pOpen->ustrLinkName, strName);
status = IoCreateSymbolicLink(&pOpen->ustrLinkName, &ustrDevName);
if(status != STATUS_SUCCESS)
{
*Status = NDIS_STATUS_FAILURE;
DbgPrint(" ProtoDrv: Create symbolic failed \n");
break;
}
ExFreePool(ustrDevName.Buffer);
ustrDevName.Buffer = NULL;
NdisAllocatePacketPool(&status,
&pOpen->hPacketPool, 16, sizeof(PACKET_RESERVED));
if(status != NDIS_STATUS_SUCCESS)
{
*Status = NDIS_STATUS_FAILURE;
break;
}
NdisInitializeEvent(&pOpen->BindEvent);
InitializeListHead(&pOpen->ResetIrpList);
KeInitializeSpinLock(&pOpen->ResetQueueLock);
InitializeListHead(&pOpen->RcvList);
KeInitializeSpinLock(&pOpen->RcvSpinLock);
NDIS_MEDIUM mediumArray = NdisMedium802_3;
UINT mediumIndex;
NdisOpenAdapter(Status,
&status,
&pOpen->hAdapter,
&mediumIndex,
&mediumArray,
sizeof(mediumArray)/sizeof(NDIS_MEDIUM),
g_data.hNdisProtocol,
pOpen,
DeviceName,
0,
NULL);
if(*Status == NDIS_STATUS_PENDING)
{
NdisWaitEvent(&pOpen->BindEvent, 0);
*Status = pOpen->Status;
}
if(*Status != NDIS_STATUS_SUCCESS)
{
DbgPrint(" ProtoDrv: OpenAdapter failed! \n");
break;
}
pOpen->nIrpCount = 0;
InterlockedExchange((PLONG)&pOpen->bBound, TRUE);
NdisInitializeEvent(&pOpen->CleanupEvent);
NdisSetEvent(&pOpen->CleanupEvent);
NdisQueryAdapterInstanceName(&pOpen->ustrAdapterName, pOpen->hAdapter);
pOpen->Medium = mediumArray;
InitializeListHead(&pOpen->AdapterListEntry);
ExInterlockedInsertTailList(&g_data.AdapterList,
&pOpen->AdapterListEntry,
&g_data.GlobalLock);
pDeviceObj->Flags &= ~DO_DEVICE_INITIALIZING;
}
while(FALSE);
if(*Status != NDIS_STATUS_SUCCESS)
{
if(pOpen != NULL && pOpen->hPacketPool != NULL)
{
NdisFreePacketPool(pOpen->hPacketPool);
}
if(pDeviceObj != NULL)
IoDeleteDevice(pDeviceObj);
if(ustrDevName.Buffer != NULL)
ExFreePool(ustrDevName.Buffer);
if(pOpen->ustrLinkName.Buffer != NULL)
{
IoDeleteSymbolicLink(&pOpen->ustrLinkName);
ExFreePool(pOpen->ustrLinkName.Buffer);
}
}
}
尹成 2010-05-01
  • 打赏
  • 举报
 回复
编译环境问题，建议你重新配置环境。
gfrsmall 2010-05-01
  • 打赏
  • 举报
 回复

// 驱动程序加载时调用DriverEntry例程
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_OBJECT pDeviceObj = NULL;
NDIS_STRING protoName = NDIS_STRING_CONST("Packet");
UNICODE_STRING ustrSymbolicLink;
BOOLEAN bSymbolicLink = FALSE;
DbgPrint(" ProtoDrv: DriverEntry... \n");
g_data.pDriverObj = pDriverObj;
do
{
UNICODE_STRING ustrDevName;
RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);
status = IoCreateDevice(pDriverObj,
0,
&ustrDevName,
FILE_DEVICE_UNKNOWN,
0,
FALSE,
&pDeviceObj);
if(!NT_SUCCESS(status))
{
DbgPrint(" ProtoDrv: CreateDevice failed \n");
break;
}
RtlInitUnicodeString(&ustrSymbolicLink, LINK_NAME);
status = IoCreateSymbolicLink(&ustrSymbolicLink, &ustrDevName);
if(!NT_SUCCESS(status))
{
DbgPrint(" ProtoDrv: CreateSymbolicLink failed \n");
break;
}
bSymbolicLink = TRUE;
pDeviceObj->Flags |= DO_BUFFERED_IO;
g_data.pControlDevice = pDeviceObj;
InitializeListHead(&g_data.AdapterList);
KeInitializeSpinLock(&g_data.GlobalLock);
NDIS_PROTOCOL_CHARACTERISTICS protocolChar;
NdisZeroMemory(&protocolChar, sizeof(protocolChar));
protocolChar.Ndis40Chars.Ndis30Chars.MajorNdisVersion = 5;
protocolChar.Ndis40Chars.Ndis30Chars.MinorNdisVersion = 0;
protocolChar.Ndis40Chars.Ndis30Chars.Name = protoName;
protocolChar.Ndis40Chars.BindAdapterHandler = ProtocolBindAdapter;
protocolChar.Ndis40Chars.UnbindAdapterHandler = ProtocolUnbindAdapter;
protocolChar.Ndis40Chars.Ndis30Chars.OpenAdapterCompleteHandler = ProtocolOpenAdapterComplete;
protocolChar.Ndis40Chars.Ndis30Chars.CloseAdapterCompleteHandler = ProtocolCloseAdapterComplete;
protocolChar.Ndis40Chars.Ndis30Chars.ReceiveHandler = ProtocolReceive;
// protocolChar.Ndis40Chars.ReceivePacketHandler = ProtocolReceivePacket;
protocolChar.Ndis40Chars.Ndis30Chars.TransferDataCompleteHandler = ProtocolTransferDataComplete;
protocolChar.Ndis40Chars.Ndis30Chars.SendCompleteHandler = ProtocolSendComplete;
protocolChar.Ndis40Chars.Ndis30Chars.ResetCompleteHandler = ProtocolResetComplete;
protocolChar.Ndis40Chars.Ndis30Chars.RequestCompleteHandler = ProtocolRequestComplete;
protocolChar.Ndis40Chars.Ndis30Chars.ReceiveCompleteHandler = ProtocolReceiveComplete;
protocolChar.Ndis40Chars.Ndis30Chars.StatusHandler = ProtocolStatus;
protocolChar.Ndis40Chars.Ndis30Chars.StatusCompleteHandler = ProtocolStatusComplete;
protocolChar.Ndis40Chars.PnPEventHandler = ProtocolPNPHandler;
NdisRegisterProtocol((PNDIS_STATUS)&status,
&g_data.hNdisProtocol, &protocolChar, sizeof(protocolChar));
if(status != NDIS_STATUS_SUCCESS)
{
status = STATUS_UNSUCCESSFUL;
break;
}
DbgPrint(" ProtoDrv: NdisRegisterProtocol success \n");
pDriverObj->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
pDriverObj->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;
pDriverObj->MajorFunction[IRP_MJ_READ] = DispatchRead;
pDriverObj->MajorFunction[IRP_MJ_WRITE] = DispatchWrite;
pDriverObj->MajorFunction[IRP_MJ_CLEANUP] = DispatchCleanup;
pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoctl;
pDriverObj->DriverUnload = DriverUnload;
status = STATUS_SUCCESS;
}while(FALSE);

if(!NT_SUCCESS(status))
{
if(pDeviceObj != NULL)
{
IoDeleteDevice(pDeviceObj);
g_data.pControlDevice = NULL;
}
if(bSymbolicLink)
{
IoDeleteSymbolicLink(&ustrSymbolicLink);
}
}
return status;
}

void DriverUnload(PDRIVER_OBJECT pDriverObj)
{
UNICODE_STRING ustrLink;
RtlInitUnicodeString(&ustrLink, LINK_NAME);
IoDeleteSymbolicLink(&ustrLink);
if(g_data.pControlDevice != NULL)
IoDeleteDevice(g_data.pControlDevice);
NDIS_STATUS status;
while(pDriverObj->DeviceObject != NULL)
{
ProtocolUnbindAdapter(&status, pDriverObj->DeviceObject->DeviceExtension, NULL);
}
NdisDeregisterProtocol(&status, g_data.hNdisProtocol);
}

NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
DbgPrint(" ProtoDrv: DispatchClose \n");
NTSTATUS status = STATUS_SUCCESS;
if(pDevObj == g_data.pControlDevice)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)pDevObj->DeviceExtension;
IoIncrement(pOpen);
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
return status;
}

NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
DbgPrint(" ProtoDrv: DispatchCreate \n");
NTSTATUS status = STATUS_SUCCESS;
if(pDevObj == g_data.pControlDevice)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)pDevObj->DeviceExtension;
IoIncrement(pOpen);
if(!pOpen->bBound)
{
status = STATUS_DEVICE_NOT_READY;
}
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
return status;
}

NTSTATUS DispatchIoctl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
PVOID pIoBuffer = pIrp->AssociatedIrp.SystemBuffer;
ULONG uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
ULONG uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
if(uIoControlCode == IOCTL_ENUM_ADAPTERS)
{
ULONG nDataLen = 0;
if(pDevObj != g_data.pControlDevice)
status = STATUS_INVALID_DEVICE_REQUEST;
else
{
status = GetAdapterList(pIoBuffer, uOutSize, &nDataLen);
if(status != STATUS_SUCCESS)
DbgPrint("GetAdapterList error ");
}
pIrp->IoStatus.Information = nDataLen;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)pDevObj->DeviceExtension;
if(pOpen == NULL || !pOpen->bBound)
{
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL;
}
IoIncrement(pOpen);
IoMarkIrpPending(pIrp);
if(uIoControlCode == IOCTL_PROTOCOL_RESET)
{
ExInterlockedInsertTailList(
&pOpen->ResetIrpList,
&pIrp->Tail.Overlay.ListEntry,
&pOpen->ResetQueueLock);
NdisReset(&status,
pOpen->hAdapter
);
if(status != NDIS_STATUS_PENDING)
{
ProtocolResetComplete(
pOpen,
status);
}
}
else if(uIoControlCode == IOCTL_PROTOCOL_SET_OID
|| uIoControlCode == IOCTL_PROTOCOL_QUERY_OID)
{
PPROTOCOL_OID_DATA pOidData = (PPROTOCOL_OID_DATA)pIoBuffer;
PINTERNAL_REQUEST pInterRequest = (PINTERNAL_REQUEST)ExAllocatePool(NonPagedPool, sizeof(INTERNAL_REQUEST));
if(pInterRequest == NULL)
{
pIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
return STATUS_PENDING;
}
pInterRequest->pIrp = pIrp;
if(uOutSize == uInSize && uOutSize >= sizeof(PROTOCOL_OID_DATA) &&
uOutSize >= sizeof(PROTOCOL_OID_DATA) - 1 + pOidData->Length)
{
if(uIoControlCode == IOCTL_PROTOCOL_SET_OID)
{
pInterRequest->Request.RequestType = NdisRequestSetInformation;
pInterRequest->Request.DATA.SET_INFORMATION.Oid = pOidData->Oid;
pInterRequest->Request.DATA.SET_INFORMATION.InformationBuffer = pOidData->Data;
pInterRequest->Request.DATA.SET_INFORMATION.InformationBufferLength = pOidData->Length;
}
else
{
pInterRequest->Request.RequestType = NdisRequestQueryInformation;
pInterRequest->Request.DATA.QUERY_INFORMATION.Oid = pOidData->Oid;
pInterRequest->Request.DATA.QUERY_INFORMATION.InformationBuffer = pOidData->Data;
pInterRequest->Request.DATA.QUERY_INFORMATION.InformationBufferLength = pOidData->Length;
}
NdisRequest(&status, pOpen->hAdapter, &pInterRequest->Request);
}
else
{
status = NDIS_STATUS_FAILURE;
pInterRequest->Request.DATA.SET_INFORMATION.BytesRead = 0;
pInterRequest->Request.DATA.QUERY_INFORMATION.BytesWritten = 0;
}
if(status != NDIS_STATUS_PENDING)
{
ProtocolRequestComplete(pOpen, &pInterRequest->Request, status);
}
}
return STATUS_PENDING;
}
gfrsmall 2010-05-01
  • 打赏
  • 举报
 回复
#define ETHERNET_HEADER_LENGTH 14
#define MAX_LINK_NAME_LENGTH 124
#define RESERVED(_p) ((PACKET_RESERVED*)((_p)->ProtocolReserved))
#define FILE_DEVICE_PROTOCOL 0x8000
#define IOCTL_PROTOCOL_SET_OID CTL_CODE(FILE_DEVICE_PROTOCOL, \
0 , METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PROTOCOL_QUERY_OID CTL_CODE(FILE_DEVICE_PROTOCOL, \
1 , METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PROTOCOL_RESET CTL_CODE(FILE_DEVICE_PROTOCOL, \
2 , METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_ENUM_ADAPTERS CTL_CODE(FILE_DEVICE_PROTOCOL, \
3 , METHOD_BUFFERED, FILE_ANY_ACCESS)

GLOBAL g_data;

void IoIncrement(POPEN_INSTANCE pOpen);
void IoDecrement(POPEN_INSTANCE pOpen);
NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchRead(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchWrite(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchCleanup(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchIoctl(PDEVICE_OBJECT pDevObj,PIRP pIrp);
void DriverUnload(PDRIVER_OBJECT pDriverObj);

VOID ProtocolBindAdapter(OUT PNDIS_STATUS Status,
IN NDIS_HANDLE BindContext,
IN PNDIS_STRING DeviceName,
IN PVOID SystemSpecific1,
IN PVOID SystemSpecific2);

VOID ProtocolUnbindAdapter(OUT PNDIS_STATUS Status,
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE UnbindContext);

VOID ProtocolOpenAdapterComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status,
IN NDIS_STATUS OpenErrorStatus);

VOID ProtocolCloseAdapterComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status);

NDIS_STATUS ProtocolReceive(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookAheadBuffer,
IN UINT LookAheadBufferSize,
IN UINT PacketSize);

VOID ProtocolTransferDataComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET pPacket,
IN NDIS_STATUS Status,
IN UINT BytesTransfered);

VOID ProtocolResetComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status);

VOID ProtocolRequestComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_REQUEST NdisRequest,
IN NDIS_STATUS Status);

VOID ProtocolSendComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET pPacket,
IN NDIS_STATUS Status);

VOID ProtocolStatus(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status,
IN PVOID StatusBuffer,
IN UINT StatusBufferSize);

VOID ProtocolStatusComplete(IN NDIS_HANDLE ProtocolBindingContext);

NDIS_STATUS ProtocolPNPHandler(IN NDIS_HANDLE ProtocolBindingContext,
IN PNET_PNP_EVENT NetPnPEvent);

VOID ProtocolReceiveComplete(IN NDIS_HANDLE ProtocolBindingContext);

void CancelReadIrp(PDEVICE_OBJECT pDeviceObj);

VOID ReadCancelRoutine(PDEVICE_OBJECT pDeviceObje,PIRP pIrp);

NTSTATUS GetAdapterList(IN PVOID Buffer,IN ULONG Length,IN OUT PULONG DataLength);
gfrsmall 2010-05-01
  • 打赏
  • 举报
 回复
VC6.0+win2000ddk 但写协议驱动是没问题的,就象如下这个协议驱动编译是没问题的....


//////////////////////////////////////////////////
// ProtocolDriver.cpp文件


#define NDIS50 1

extern "C"
{
#include <ntddk.h>
#include <ndis.h>
#include <stdio.h>
}

#pragma comment(lib,"ndis")

#define DEVICE_NAME L"\\Device\\devNdisProt"
#define LINK_NAME L"\\DosDevices\\slNdisProt"

typedef struct _OPEN_INSTANCE
{
LIST_ENTRY AdapterListEntry;
PDEVICE_OBJECT pDeviceObj;
UNICODE_STRING ustrAdapterName;
UNICODE_STRING ustrLinkName;
NDIS_HANDLE hAdapter;
BOOLEAN bBound;
NDIS_STATUS Status;
ULONG nIrpCount;
NDIS_HANDLE hPacketPool;
LIST_ENTRY RcvList;
KSPIN_LOCK RcvSpinLock;
LIST_ENTRY ResetIrpList;
KSPIN_LOCK ResetQueueLock;
NDIS_EVENT BindEvent;
NDIS_EVENT CleanupEvent;
NDIS_MEDIUM Medium;
} OPEN_INSTANCE, *POPEN_INSTANCE;

typedef struct _GLOBAL
{
PDRIVER_OBJECT pDriverObj;
NDIS_HANDLE hNdisProtocol;
LIST_ENTRY AdapterList;
KSPIN_LOCK GlobalLock;
PDEVICE_OBJECT pControlDevice;
}GLOBAL;

typedef struct _PACKET_RESERVED
{
LIST_ENTRY ListElement;
PIRP pIrp;
PMDL pMdl;
}PACKET_RESERVED,*PPACKET_RESERVED;

typedef struct _PROTOCOL_OID_DATA
{
ULONG Oid;
ULONG Length;
UCHAR Data[1];
} PROTOCOL_OID_DATA, *PPROTOCOL_OID_DATA;

typedef struct _INTERNAL_REQUEST
{
PIRP pIrp;
NDIS_REQUEST Request;
}INTERNAL_REQUEST, *PINTERNAL_REQUEST;
AIHANZI 2010-05-01
  • 打赏
  • 举报
 回复
编译环境问题。。。你用的WDK还是DDK 的？你用什么环境搭配？VC6.0+WDK 还是VS2005+DDK+DDKWISZAD????
我之前也遇到过这样的问题
和菜鸟一起学linux：第六篇：将LED驱动编译到内核
第六篇：将LED驱动编译到内核日期：2009-3-12 内核的drivers目录里提供了LED的驱动文件，查看后，发现管脚定义也和我板子上的定义一致（呵呵）于是就把内核提供的LED例子弄的我存放文件的目录，想编译下，主要是...
教你告别嵌入式"菜鸟"开发者--单片机篇（转载）
”等等等等一系列的问题，实在是看多了也感到烦了，今天，就由我电子白菜厚着面皮，顶着无数老虾的砖头，在这里写上一篇单片机学习心得，让菜鸟们勇敢地跨出第一步。 首先解释什么是虾米先，以我个人意见吧，1。来...
我的软件工程之路（二）
上次写了一篇《我的软件工程之路（一）》，如果你没看过，可以先去看看，名字后面挂了一个（一），当然就意味着要继续写下去，所以这篇文章就应运而生了。 两个月的时间过去了，又紧锣密鼓地学习了两个月，我依然...
连载IT小说《失业的程序员》讲述一个Android开发者的奋斗史
失业的程序员(一)  不小心，我失业了。 　原因是前几天和我的部门...　我好说歹说了一个上午，甚至我都提到了“真、善、美”的思想，都没有让猪刚烈回心转意。一时冲动拍了桌子，提出我也和我的组员一起"西去
虾米是怎样炼成的(转&收藏)
虾米是怎样炼成的 ...”等等等等一系列的问题，实在是看 多了也感到烦了，今天，就由我电子白菜厚着面皮，顶着无数老虾的砖头，在这里写上一 篇单片机学习心得，让菜鸟们勇敢地跨出第一步。 首先解释什...
网络编程

18,356

社区成员

64,214

社区内容

发帖
与我相关
我的任务
社区描述
VC/MFC 网络编程
c++c语言开发语言 技术论坛（原bbs）
社区管理员
  • 网络编程
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章