ndis.c

ndiswrapper工具

{
	NdisAllocatePacket(status, packet, pool);
}

wstdcall void WIN_FUNC(NdisFreePacket,1)
	(struct ndis_packet *descr)
{
	struct ndis_packet_pool *pool;

	TRACEENTER3("packet: %p, pool: %p", descr, descr->private.pool);
	pool = descr->private.pool;
	if (!pool) {
		ERROR("pool for descriptor %p is invalid", descr);
		TRACEEXIT4(return);
	}
	atomic_dec_var(pool->num_used_descr);
	if (pool->num_allocated_descr > MAX_ALLOCATED_NDIS_PACKETS) {
		kfree(descr);
		atomic_dec_var(pool->num_allocated_descr);
	} else {
		struct ndis_packet_oob_data *oob_data;
		oob_data = NDIS_PACKET_OOB_DATA(descr);
		atomic_insert_list_head(pool->free_descr, oob_data->next, descr);
	}
	TRACEEXIT4(return);
}

wstdcall void WIN_FUNC(NdisCopyFromPacketToPacketSafe,7)
	(struct ndis_packet *dst, UINT dst_offset, UINT num_to_copy,
	 struct ndis_packet *src, UINT src_offset, UINT *num_copied,
	 enum mm_page_priority priority)
{
	UINT dst_n, src_n, n, left;
	ndis_buffer *dst_buf;
	ndis_buffer *src_buf;

	TRACEENTER4("");
	if (!dst || !src) {
		*num_copied = 0;
		TRACEEXIT4(return);
	}

	dst_buf = dst->private.buffer_head;
	src_buf = src->private.buffer_head;

	if (!dst_buf || !src_buf) {
		*num_copied = 0;
		TRACEEXIT4(return);
	}
	dst_n = MmGetMdlByteCount(dst_buf) - dst_offset;
	src_n = MmGetMdlByteCount(src_buf) - src_offset;

	n = min(src_n, dst_n);
	n = min(n, num_to_copy);
	memcpy(MmGetSystemAddressForMdl(dst_buf) + dst_offset,
	       MmGetSystemAddressForMdl(src_buf) + src_offset,
	       n);

	left = num_to_copy - n;
	while (left > 0) {
		src_offset += n;
		dst_offset += n;
		dst_n -= n;
		src_n -= n;
		if (dst_n == 0) {
			dst_buf = dst_buf->next;
			if (!dst_buf)
				break;
			dst_n = MmGetMdlByteCount(dst_buf);
			dst_offset = 0;
		}
		if (src_n == 0) {
			src_buf = src_buf->next;
			if (!src_buf)
				break;
			src_n = MmGetMdlByteCount(src_buf);
			src_offset = 0;
		}

		n = min(src_n, dst_n);
		n = min(n, left);
		memcpy(MmGetSystemAddressForMdl(dst_buf) + dst_offset,
		       MmGetSystemAddressForMdl(src_buf) + src_offset,
		       n);
		left -= n;
	}
	*num_copied = num_to_copy - left;
	TRACEEXIT4(return);
}

wstdcall void WIN_FUNC(NdisCopyFromPacketToPacket,6)
	(struct ndis_packet *dst, UINT dst_offset, UINT num_to_copy,
	 struct ndis_packet *src, UINT src_offset, UINT *num_copied)
{
	NdisCopyFromPacketToPacketSafe(dst, dst_offset, num_to_copy,
				       src, src_offset, num_copied,
				       NormalPagePriority);
	return;
}

wstdcall void WIN_FUNC(NdisIMCopySendPerPacketInfo,2)
	(struct ndis_packet *dst, struct ndis_packet *src)
{
	struct ndis_packet_oob_data *dst_oob, *src_oob;
	dst_oob = NDIS_PACKET_OOB_DATA(dst);
	src_oob = NDIS_PACKET_OOB_DATA(src);
	memcpy(&dst_oob->extension, &src_oob->extension,
	       sizeof(dst_oob->extension));
	return;
}

wstdcall void WIN_FUNC(NdisSend,3)
	(NDIS_STATUS *status, struct ndis_miniport_block *nmb,
	 struct ndis_packet *packet)
{
	struct wrap_ndis_device *wnd = nmb->wnd;
	struct miniport_char *miniport;
	KIRQL irql;

	miniport = &wnd->wd->driver->ndis_driver->miniport;
	if (miniport->send_packets) {
		irql = serialize_lock_irql(wnd);
		LIN2WIN3(miniport->send_packets, wnd->nmb->adapter_ctx,
			 &packet, 1);
		serialize_unlock_irql(wnd, irql);
		if (deserialized_driver(wnd))
			*status = NDIS_STATUS_PENDING;
		else {
			struct ndis_packet_oob_data *oob_data;
			oob_data = NDIS_PACKET_OOB_DATA(packet);
			*status = oob_data->status;
			switch (*status) {
			case NDIS_STATUS_SUCCESS:
				free_tx_packet(wnd, packet, *status);
				break;
			case NDIS_STATUS_PENDING:
				break;
			case NDIS_STATUS_RESOURCES:
				atomic_dec_var(wnd->tx_ok);
				break;
			case NDIS_STATUS_FAILURE:
			default:
				free_tx_packet(wnd, packet, *status);
				break;
			}
		}
	} else {
		irql = serialize_lock_irql(wnd);
		*status = LIN2WIN3(miniport->send, wnd->nmb->adapter_ctx,
				   packet, 0);
		serialize_unlock_irql(wnd, irql);
		switch (*status) {
		case NDIS_STATUS_SUCCESS:
			free_tx_packet(wnd, packet, *status);
			break;
		case NDIS_STATUS_PENDING:
			break;
		case NDIS_STATUS_RESOURCES:
			atomic_dec_var(wnd->tx_ok);
			break;
		case NDIS_STATUS_FAILURE:
		default:
			free_tx_packet(wnd, packet, *status);
			break;
		}
	}
	TRACEEXIT3(return);
}

wstdcall void wrap_miniport_timer(struct kdpc *kdpc, void *ctx, void *arg1,
				  void *arg2)
{
	struct ndis_miniport_timer *timer;
	struct ndis_miniport_block *nmb;

	timer = ctx;
	TRACEENTER5("timer: %p, func: %p, ctx: %p, nmb: %p",
		    timer, timer->func, timer->ctx, timer->nmb);
	nmb = timer->nmb;
	/* already called at DISPATCH_LEVEL */
	if (!deserialized_driver(nmb->wnd))
		serialize_lock(nmb->wnd);
	LIN2WIN4(timer->func, kdpc, timer->ctx, kdpc->arg1, kdpc->arg2);
	if (!deserialized_driver(nmb->wnd))
		serialize_unlock(nmb->wnd);
	TRACEEXIT5(return);
}
WIN_FUNC_DECL(wrap_miniport_timer,4)

wstdcall void WIN_FUNC(NdisMInitializeTimer,4)
	(struct ndis_miniport_timer *timer, struct ndis_miniport_block *nmb,
	 DPC func, void *ctx)
{
	TRACEENTER4("timer: %p, func: %p, ctx: %p, nmb: %p",
		    timer, func, ctx, nmb);
	timer->func = func;
	timer->ctx = ctx;
	timer->nmb = nmb;
//	KeInitializeDpc(&timer->kdpc, func, ctx);
	KeInitializeDpc(&timer->kdpc, WIN_FUNC_PTR(wrap_miniport_timer,4),
			timer);
	wrap_init_timer(&timer->nt_timer, NotificationTimer, &timer->kdpc, nmb);
	TRACEEXIT4(return);
}

wstdcall void WIN_FUNC(NdisMSetPeriodicTimer,2)
	(struct ndis_miniport_timer *timer, UINT period_ms)
{
	unsigned long expires = MSEC_TO_HZ(period_ms) + 1;

	TRACEENTER4("%p, %u, %ld", timer, period_ms, expires);
	wrap_set_timer(&timer->nt_timer, expires, expires, NULL);
	TRACEEXIT4(return);
}

wstdcall void WIN_FUNC(NdisMCancelTimer,2)
	(struct ndis_miniport_timer *timer, BOOLEAN *canceled)
{
	TRACEENTER4("%p", timer);
	*canceled = KeCancelTimer(&timer->nt_timer);
	TRACEEXIT4(return);
}

wstdcall void WIN_FUNC(NdisInitializeTimer,3)
	(struct ndis_timer *timer, void *func, void *ctx)
{
	TRACEENTER4("%p, %p, %p", timer, func, ctx);
	KeInitializeDpc(&timer->kdpc, func, ctx);
	wrap_init_timer(&timer->nt_timer, NotificationTimer, &timer->kdpc, NULL);
	TRACEEXIT4(return);
}

/* NdisMSetTimer is a macro that calls NdisSetTimer with
 * ndis_miniport_timer typecast to ndis_timer */

wstdcall void WIN_FUNC(NdisSetTimer,2)
	(struct ndis_timer *timer, UINT duetime_ms)
{
	unsigned long expires = MSEC_TO_HZ(duetime_ms) + 1;

	TRACEENTER4("%p, %p, %u, %ld", timer, timer->nt_timer.wrap_timer,
		    duetime_ms, expires);
	wrap_set_timer(&timer->nt_timer, expires, 0, NULL);
	TRACEEXIT4(return);
}

wstdcall void WIN_FUNC(NdisCancelTimer,2)
	(struct ndis_timer *timer, BOOLEAN *canceled)
{
	TRACEENTER4("%p", timer);
	*canceled = KeCancelTimer(&timer->nt_timer);
	TRACEEXIT4(return);
}

wstdcall void WIN_FUNC(NdisReadNetworkAddress,4)
	(NDIS_STATUS *status, void **addr, UINT *len,
	 struct ndis_miniport_block *nmb)
{
	struct wrap_ndis_device *wnd = nmb->wnd;
	struct ndis_configuration_parameter *param;
	struct unicode_string key;
	struct ansi_string ansi;
	int ret;

	TRACEENTER1("");
	RtlInitAnsiString(&ansi, "NetworkAddress");
	*len = 0;
	*status = NDIS_STATUS_FAILURE;
	if (RtlAnsiStringToUnicodeString(&key, &ansi, TRUE) != STATUS_SUCCESS)
		TRACEEXIT1(return);

	NdisReadConfiguration(status, &param, nmb, &key, NdisParameterString);
	RtlFreeUnicodeString(&key);

	if (*status == NDIS_STATUS_SUCCESS) {
		int int_mac[ETH_ALEN];
		ret = RtlUnicodeStringToAnsiString(&ansi, &param->data.string,
						   TRUE);
		if (ret != NDIS_STATUS_SUCCESS)
			TRACEEXIT1(return);

		ret = sscanf(ansi.buf, MACSTR, MACINTADR(int_mac));
		if (ret != ETH_ALEN)
			ret = sscanf(ansi.buf, MACSTRSEP, MACINTADR(int_mac));
		RtlFreeAnsiString(&ansi);
		if (ret == ETH_ALEN) {
			int i;
			for (i = 0; i < ETH_ALEN; i++)
				wnd->mac[i] = int_mac[i];
			printk(KERN_INFO "%s: %s ethernet device " MACSTRSEP
			       "\n", wnd->net_dev->name, DRIVER_NAME,
			       MAC2STR(wnd->mac));
			*len = ETH_ALEN;
			*addr = wnd->mac;
			*status = NDIS_STATUS_SUCCESS;
		}
	}

	TRACEEXIT1(return);
}

wstdcall void WIN_FUNC(NdisMRegisterAdapterShutdownHandler,3)
	(struct ndis_miniport_block *nmb, void *ctx, void *func)
{
	struct wrap_ndis_device *wnd = nmb->wnd;
	TRACEENTER1("%p", func);
	wnd->wd->driver->ndis_driver->miniport.shutdown = func;
	wnd->shutdown_ctx = ctx;
}

wstdcall void WIN_FUNC(NdisMDeregisterAdapterShutdownHandler,1)
	(struct ndis_miniport_block *nmb)
{
	struct wrap_ndis_device *wnd = nmb->wnd;
	wnd->wd->driver->ndis_driver->miniport.shutdown = NULL;
	wnd->shutdown_ctx = NULL;
}

static void ndis_irq_handler(unsigned long data)
{
	struct wrap_ndis_device *wnd = (struct wrap_ndis_device *)data;
	struct miniport_char *miniport;

	miniport = &wnd->wd->driver->ndis_driver->miniport;
	if_serialize_lock(wnd);
	LIN2WIN1(miniport->handle_interrupt, wnd->nmb->adapter_ctx);
	if (miniport->enable_interrupt)
		LIN2WIN1(miniport->enable_interrupt, wnd->nmb->adapter_ctx);
	if_serialize_unlock(wnd);
}

irqreturn_t ndis_isr(int irq, void *data, struct pt_regs *pt_regs)
{
	struct wrap_ndis_device *wnd = (struct wrap_ndis_device *)data;
	struct miniport_char *miniport;
	BOOLEAN recognized, queue_handler;

	miniport = &wnd->wd->driver->ndis_driver->miniport;
	/* this spinlock should be shared with NdisMSynchronizeWithInterrupt
	 */
	nt_spin_lock(&wnd->ndis_irq->lock);
	if (wnd->ndis_irq->req_isr)
		LIN2WIN3(miniport->isr, &recognized, &queue_handler,
			 wnd->nmb->adapter_ctx);
	else { //if (miniport->disable_interrupt)
		LIN2WIN1(miniport->disable_interrupt, wnd->nmb->adapter_ctx);
		/* it is not shared interrupt, so handler must be called */
		recognized = queue_handler = TRUE;
	}
	nt_spin_unlock(&wnd->ndis_irq->lock);
	if (recognized) {
		if (queue_handler)
			tasklet_schedule(&wnd->irq_tasklet);
		return IRQ_HANDLED;
	}
	return IRQ_NONE;
}

wstdcall NDIS_STATUS WIN_FUNC(NdisMRegisterInterrupt,7)
	(struct ndis_irq *ndis_irq, struct ndis_miniport_block *nmb,
	 UINT vector, UINT level, BOOLEAN req_isr,
	 BOOLEAN shared, enum kinterrupt_mode mode)
{
	struct wrap_ndis_device *wnd = nmb->wnd;
	TRACEENTER1("%p, vector:%d, level:%d, req_isr:%d, shared:%d, mode:%d",
		    ndis_irq, vector, level, req_isr, shared, mode);

	ndis_irq->irq.irq = vector;
	ndis_irq->wnd = wnd;
	ndis_irq->req_isr = req_isr;
	if (shared && !req_isr)
		WARNING("shared but dynamic interrupt!");
	ndis_irq->shared = shared;
	nt_spin_lock_init(&ndis_irq->lock);
	wnd->ndis_irq = ndis_irq;
	tasklet_init(&wnd->irq_tasklet, ndis_irq_handler, (unsigned long)wnd);
	if (request_irq(vector, ndis_isr, req_isr ? SA_SHIRQ : 0,
			wnd->net_dev->name, wnd)) {
		printk(KERN_WARNING "%s: request for IRQ %d failed\n",
		       DRIVER_NAME, vector);
		TRACEEXIT1(return NDIS_STATUS_RESOURCES);
	}
	ndis_irq->enabled = 1;
	printk(KERN_INFO "%s: using IRQ %d\n", DRIVER_NAME, vector);
	TRACEEXIT1(return NDIS_STATUS_SUCCESS);
}

wstdcall void WIN_FUNC(NdisMDeregisterInterrupt,1)
	(struct ndis_irq *ndis_irq)
{
	struct wrap_ndis_device *wnd;

	TRACEENTER1("%p", ndis_irq);

	if (!ndis_irq)
		TRACEEXIT1(return);
	wnd = ndis_irq->wnd;
	if (!wnd)
		TRACEEXIT1(return);

	free_irq(ndis_irq->irq.irq, wnd);
	tasklet_kill(&wnd->irq_tasklet);
	ndis_irq->enabled = 0;
	ndis_irq->wnd = NULL;
	wnd->ndis_irq = NULL;
	TRACEEXIT1(return);
}

wstdcall BOOLEAN WIN_FUNC(NdisMSynchronizeWithInterrupt,3)
	(struct ndis_irq *ndis_irq, void *func, void *ctx)
{
	BOOLEAN ret;
	BOOLEAN (*sync_func)(void *ctx) wstdcall;
	unsigned long flags;

	TRACEENTER6("%p %p", func, ctx);
	sync_func = func;
	nt_spin_lock_irqsave(&ndis_irq->lock, flags);
	ret = LIN2WIN1(sync_func, ctx);
	nt_spin_unlock_irqrestore(&ndis_irq->lock, flags);
	DBGTRACE6("ret: %d", ret);
	TRACEEXIT6(return ret);
}

/* called via function pointer; but 64-bit RNDIS driver calls directly */
wstdcall void WIN_FUNC(NdisMIndicateStatus,4)
	(struct ndis_miniport_block *nmb, NDIS_STATUS status,
	 void *buf, UINT len)
{
	struct wrap_ndis_device *wnd = nmb->wnd;
	struct ndis_status_indication *si;
	struct ndis_auth_req *auth_req;
	struct ndis_radio_status_indication *radio_status;

	TRACEENTER2("status=0x%x len=%d", status, len);
	switch (status) {
	case NDIS_STATUS_MEDIA_DISCONNECT:
		netif_carrier_off(wnd->net_dev);
		set_bit(LINK_STATUS_CHANGED, &wnd->wrap_ndis_pending_work);
		schedule_wrap_work(&wnd->wrap_ndis_work);
		break;
	case NDIS_STATUS_MEDIA_CONNECT:
		netif_carrier_on(wnd->net_dev);
		set_bit(LINK_STATUS_CHANGED, &wnd->wrap_ndis_pending_work);
		schedule_wrap_work(&wnd->wrap_ndis_work);
		break;
	case NDIS_STATUS_MEDIA_SPECIFIC_INDICATION:
		if (!buf)
			break;
		si = buf;
		DBGTRACE2("status_type=%d", si->status_type);

		switch (si->status_type) {
		case Ndis802_11StatusType_Authentication:
			buf = (char *)buf + sizeof(*si);
			len -= sizeof(*si);
			while (len > 0) {
				auth_req = (struct ndis_auth_req *)buf;
				DBGTRACE1(MACSTRSEP, MAC2STR(auth_req->bssid));
				if (auth_req->flags & 0x01)
					DBGTRACE2("reqauth");
				if (auth_req->flags & 0x02)
					DBGTRACE2("keyupdate");
				if (auth_req->flags & 0x06)
					DBGTRACE2("pairwise_error");
				if (auth_req->flags & 0x0E)
					DBGTRACE2("group_error");
				/* TODO: report to wpa_supplicant */
				len -= auth_req->length;
				buf = (char *)buf + auth_req->length;
			}
			break;