vbscript: Added this object to identifier lookup chanin.
[wine] / dlls / netapi32 / nbcmdqueue.c
1 /* Copyright (c) 2003 Juan Lang
2  *
3  * This library is free software; you can redistribute it and/or
4  * modify it under the terms of the GNU Lesser General Public
5  * License as published by the Free Software Foundation; either
6  * version 2.1 of the License, or (at your option) any later version.
7  *
8  * This library is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * Lesser General Public License for more details.
12  *
13  * You should have received a copy of the GNU Lesser General Public
14  * License along with this library; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
16  */
17 #include "config.h"
18 #include "wine/debug.h"
19 #include "nbcmdqueue.h"
20
21 WINE_DEFAULT_DEBUG_CHANNEL(netbios);
22
23 struct NBCmdQueue
24 {
25     HANDLE           heap;
26     CRITICAL_SECTION cs;
27     PNCB             head;
28 };
29
30 #define CANCEL_EVENT_PTR(ncb) (PHANDLE)((ncb)->ncb_reserve)
31 #define NEXT_PTR(ncb) (PNCB *)((ncb)->ncb_reserve + sizeof(HANDLE))
32
33 /* The reserved area of an ncb will be used for the following data:
34  * - a cancelled flag (BOOL, 4 bytes??)
35  * - a handle to an event that's set by a cancelled command on completion
36  *   (HANDLE, 4 bytes)
37  * These members are used in the following way
38  * - on cancel, set the event member of the reserved field (with create event)
39  * - NBCmdComplete will delete the ncb from the queue of there's no event;
40  *   otherwise it will set the event and not delete the ncb
41  * - cancel must lock the queue before finding the ncb in it, and can unlock it
42  *   once it's set the event (and the cancelled flag)
43  * - NBCmdComplete must lock the queue before attempting to remove the ncb or
44  *   check the event
45  * - NBCmdQueueCancelAll will lock the queue, and cancel all ncb's in the queue.
46  *   It'll then unlock the queue, and wait on the event in the head of the queue
47  *   until there's no more ncb's in the queue.
48  * Space optimization: use the handle as a boolean.  NULL == 0 => not cancelled.
49  * Non-NULL == valid handle => cancelled.  This allows storing a next pointer
50  * in the ncb's reserved field as well, avoiding a memory alloc for a new
51  * command (cool).
52  */
53
54 struct NBCmdQueue *NBCmdQueueCreate(HANDLE heap)
55 {
56     struct NBCmdQueue *queue;
57
58     if (heap == NULL)
59         heap = GetProcessHeap();
60     queue = HeapAlloc(heap, 0, sizeof(struct NBCmdQueue));
61     if (queue)
62     {
63         queue->heap = heap;
64         InitializeCriticalSection(&queue->cs);
65         queue->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": NBCmdQueue.cs");
66         queue->head = NULL;
67     }
68     return queue;
69 }
70
71 UCHAR NBCmdQueueAdd(struct NBCmdQueue *queue, PNCB ncb)
72 {
73     UCHAR ret;
74
75     TRACE(": queue %p, ncb %p\n", queue, ncb);
76
77     if (!queue)
78         return NRC_BADDR;
79     if (!ncb)
80         return NRC_INVADDRESS;
81
82     *CANCEL_EVENT_PTR(ncb) = NULL;
83     EnterCriticalSection(&queue->cs);
84     *NEXT_PTR(ncb) = queue->head;
85     queue->head = ncb;
86     ret = NRC_GOODRET;
87     LeaveCriticalSection(&queue->cs);
88     TRACE("returning 0x%02x\n", ret);
89     return ret;
90 }
91
92 static PNCB *NBCmdQueueFindNBC(struct NBCmdQueue *queue, PNCB ncb)
93 {
94     PNCB *ret;
95
96     if (!queue || !ncb)
97         ret = NULL;
98     else
99     {
100         ret = &queue->head;
101         while (ret && *ret != ncb)
102             ret = NEXT_PTR(*ret);
103     }
104     return ret;
105 }
106
107 UCHAR NBCmdQueueCancel(struct NBCmdQueue *queue, PNCB ncb)
108 {
109     UCHAR ret;
110     PNCB *spot;
111
112     TRACE(": queue %p, ncb %p\n", queue, ncb);
113
114     if (!queue)
115         return NRC_BADDR;
116     if (!ncb)
117         return NRC_INVADDRESS;
118
119     EnterCriticalSection(&queue->cs);
120     spot = NBCmdQueueFindNBC(queue, ncb);
121     if (spot)
122     {
123         *CANCEL_EVENT_PTR(*spot) = CreateEventW(NULL, FALSE, FALSE, NULL);
124         WaitForSingleObject(*CANCEL_EVENT_PTR(*spot), INFINITE);
125         CloseHandle(*CANCEL_EVENT_PTR(*spot));
126         *spot = *NEXT_PTR(*spot);
127         if (ncb->ncb_retcode == NRC_CMDCAN)
128             ret = NRC_CMDCAN;
129         else
130             ret = NRC_CANOCCR;
131     }
132     else
133         ret = NRC_INVADDRESS;
134     LeaveCriticalSection(&queue->cs);
135     TRACE("returning 0x%02x\n", ret);
136     return ret;
137 }
138
139 UCHAR NBCmdQueueComplete(struct NBCmdQueue *queue, PNCB ncb, UCHAR retcode)
140 {
141     UCHAR ret;
142     PNCB *spot;
143
144     TRACE(": queue %p, ncb %p\n", queue, ncb);
145
146     if (!queue)
147         return NRC_BADDR;
148     if (!ncb)
149         return NRC_INVADDRESS;
150
151     EnterCriticalSection(&queue->cs);
152     spot = NBCmdQueueFindNBC(queue, ncb);
153     if (spot)
154     {
155         if (*CANCEL_EVENT_PTR(*spot))
156             SetEvent(*CANCEL_EVENT_PTR(*spot));
157         else
158             *spot = *NEXT_PTR(*spot);
159         ret = NRC_GOODRET;
160     }
161     else
162         ret = NRC_INVADDRESS;
163     LeaveCriticalSection(&queue->cs);
164     TRACE("returning 0x%02x\n", ret);
165     return ret;
166 }
167
168 UCHAR NBCmdQueueCancelAll(struct NBCmdQueue *queue)
169 {
170     UCHAR ret;
171
172     TRACE(": queue %p\n", queue);
173
174     if (!queue)
175         return NRC_BADDR;
176
177     EnterCriticalSection(&queue->cs);
178     while (queue->head)
179     {
180         TRACE(": waiting for ncb %p (command 0x%02x)\n", queue->head,
181          queue->head->ncb_command);
182         NBCmdQueueCancel(queue, queue->head);
183     }
184     LeaveCriticalSection(&queue->cs);
185     ret = NRC_GOODRET;
186     TRACE("returning 0x%02x\n", ret);
187     return ret;
188 }
189
190 void NBCmdQueueDestroy(struct NBCmdQueue *queue)
191 {
192     TRACE(": queue %p\n", queue);
193
194     if (queue)
195     {
196         NBCmdQueueCancelAll(queue);
197         queue->cs.DebugInfo->Spare[0] = 0;
198         DeleteCriticalSection(&queue->cs);
199         HeapFree(queue->heap, 0, queue);
200     }
201 }