FindFirstFile on root directory should fail.
[wine] / server / serial.c
1 /*
2  * Server-side serial port communications management
3  *
4  * Copyright (C) 1998 Alexandre Julliard
5  * Copyright (C) 2000,2001 Mike McCormack
6  *
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <fcntl.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <stdlib.h>
31 #include <sys/time.h>
32 #include <sys/types.h>
33 #include <time.h>
34 #include <unistd.h>
35 #ifdef HAVE_UTIME_H
36 #include <utime.h>
37 #endif
38 #ifdef HAVE_TERMIOS_H
39 #include <termios.h>
40 #endif
41 #ifdef HAVE_SYS_IOCTL_H
42 #include <sys/ioctl.h>
43 #endif
44
45 #include "winerror.h"
46 #include "winbase.h"
47
48 #include "file.h"
49 #include "handle.h"
50 #include "thread.h"
51 #include "request.h"
52 #include "async.h"
53
54 static void serial_dump( struct object *obj, int verbose );
55 static struct fd *serial_get_fd( struct object *obj );
56 static void serial_destroy(struct object *obj);
57
58 static int serial_get_poll_events( struct fd *fd );
59 static void serial_poll_event( struct fd *fd, int event );
60 static int serial_get_info( struct fd *fd, struct get_file_info_reply *reply, int *flags );
61 static int serial_flush( struct fd *fd );
62 static void serial_queue_async(struct fd *fd, void *ptr, unsigned int status, int type, int count);
63
64 struct serial
65 {
66     struct object       obj;
67     struct fd          *fd;
68     unsigned int        access;
69     unsigned int        attrib;
70
71     /* timeout values */
72     unsigned int        readinterval;
73     unsigned int        readconst;
74     unsigned int        readmult;
75     unsigned int        writeconst;
76     unsigned int        writemult;
77
78     unsigned int        eventmask;
79     unsigned int        commerror;
80
81     struct termios      original;
82
83     struct async_queue  read_q;
84     struct async_queue  write_q;
85     struct async_queue  wait_q;
86
87     /* FIXME: add dcb, comm status, handler module, sharing */
88 };
89
90 static const struct object_ops serial_ops =
91 {
92     sizeof(struct serial),        /* size */
93     serial_dump,                  /* dump */
94     default_fd_add_queue,         /* add_queue */
95     default_fd_remove_queue,      /* remove_queue */
96     default_fd_signaled,          /* signaled */
97     no_satisfied,                 /* satisfied */
98     serial_get_fd,                /* get_fd */
99     serial_destroy                /* destroy */
100 };
101
102 static const struct fd_ops serial_fd_ops =
103 {
104     serial_get_poll_events,       /* get_poll_events */
105     serial_poll_event,            /* poll_event */
106     serial_flush,                 /* flush */
107     serial_get_info,              /* get_file_info */
108     serial_queue_async            /* queue_async */
109 };
110
111 static struct serial *create_serial( const char *nameptr, size_t len, unsigned int access, int attributes )
112 {
113     struct serial *serial;
114     struct termios tios;
115     int fd, flags = 0;
116     char *name;
117
118     if (!(name = mem_alloc( len + 1 ))) return NULL;
119     memcpy( name, nameptr, len );
120     name[len] = 0;
121
122     switch(access & (GENERIC_READ | GENERIC_WRITE))
123     {
124     case GENERIC_READ:  flags |= O_RDONLY; break;
125     case GENERIC_WRITE: flags |= O_WRONLY; break;
126     case GENERIC_READ|GENERIC_WRITE: flags |= O_RDWR; break;
127     default: break;
128     }
129
130     flags |= O_NONBLOCK;
131
132     fd = open( name, flags );
133     free( name );
134     if (fd < 0)
135     {
136         file_set_error();
137         return NULL;
138     }
139
140     /* check its really a serial port */
141     if (tcgetattr(fd,&tios))
142     {
143         file_set_error();
144         close( fd );
145         return NULL;
146     }
147
148     /* set the fd back to blocking if necessary */
149     if( ! (attributes & FILE_FLAG_OVERLAPPED) )
150        if(0>fcntl(fd, F_SETFL, 0))
151            perror("fcntl");
152
153     if (!(serial = alloc_object( &serial_ops )))
154     {
155         close( fd );
156         return NULL;
157     }
158     serial->attrib       = attributes;
159     serial->access       = access;
160     serial->readinterval = 0;
161     serial->readmult     = 0;
162     serial->readconst    = 0;
163     serial->writemult    = 0;
164     serial->writeconst   = 0;
165     serial->eventmask    = 0;
166     serial->commerror    = 0;
167     init_async_queue(&serial->read_q);
168     init_async_queue(&serial->write_q);
169     init_async_queue(&serial->wait_q);
170     if (!(serial->fd = create_anonymous_fd( &serial_fd_ops, fd, &serial->obj )))
171     {
172         release_object( serial );
173         return NULL;
174     }
175     return serial;
176 }
177
178 static struct fd *serial_get_fd( struct object *obj )
179 {
180     struct serial *serial = (struct serial *)obj;
181     return (struct fd *)grab_object( serial->fd );
182 }
183
184 static void serial_destroy( struct object *obj)
185 {
186     struct serial *serial = (struct serial *)obj;
187
188     destroy_async_queue(&serial->read_q);
189     destroy_async_queue(&serial->write_q);
190     destroy_async_queue(&serial->wait_q);
191     if (serial->fd) release_object( serial->fd );
192 }
193
194 static void serial_dump( struct object *obj, int verbose )
195 {
196     struct serial *serial = (struct serial *)obj;
197     assert( obj->ops == &serial_ops );
198     fprintf( stderr, "Port fd=%p mask=%x\n", serial->fd, serial->eventmask );
199 }
200
201 static struct serial *get_serial_obj( struct process *process, obj_handle_t handle, unsigned int access )
202 {
203     return (struct serial *)get_handle_obj( process, handle, access, &serial_ops );
204 }
205
206 static int serial_get_poll_events( struct fd *fd )
207 {
208     struct serial *serial = get_fd_user( fd );
209     int events = 0;
210     assert( serial->obj.ops == &serial_ops );
211
212     if(IS_READY(serial->read_q))
213         events |= POLLIN;
214     if(IS_READY(serial->write_q))
215         events |= POLLOUT;
216     if(IS_READY(serial->wait_q))
217         events |= POLLIN;
218
219     /* fprintf(stderr,"poll events are %04x\n",events); */
220
221     return events;
222 }
223
224 static int serial_get_info( struct fd *fd, struct get_file_info_reply *reply, int *flags )
225 {
226     struct serial *serial = get_fd_user( fd );
227     assert( serial->obj.ops == &serial_ops );
228
229     if (reply)
230     {
231         reply->type        = FILE_TYPE_CHAR;
232         reply->attr        = 0;
233         reply->access_time = 0;
234         reply->write_time  = 0;
235         reply->size_high   = 0;
236         reply->size_low    = 0;
237         reply->links       = 0;
238         reply->index_high  = 0;
239         reply->index_low   = 0;
240         reply->serial      = 0;
241     }
242
243     *flags = 0;
244     if(serial->attrib & FILE_FLAG_OVERLAPPED)
245         *flags |= FD_FLAG_OVERLAPPED;
246     else if(!((serial->readinterval == MAXDWORD) &&
247               (serial->readmult == 0) && (serial->readconst == 0)) )
248         *flags |= FD_FLAG_TIMEOUT;
249
250     return FD_TYPE_DEFAULT;
251 }
252
253 static void serial_poll_event(struct fd *fd, int event)
254 {
255     struct serial *serial = get_fd_user( fd );
256
257     /* fprintf(stderr,"Poll event %02x\n",event); */
258
259     if(IS_READY(serial->read_q) && (POLLIN & event) )
260         async_notify(serial->read_q.head,STATUS_ALERTED);
261
262     if(IS_READY(serial->write_q) && (POLLOUT & event) )
263         async_notify(serial->write_q.head,STATUS_ALERTED);
264
265     if(IS_READY(serial->wait_q) && (POLLIN & event) )
266         async_notify(serial->wait_q.head,STATUS_ALERTED);
267
268     set_fd_events( fd, serial_get_poll_events(fd) );
269 }
270
271 static void serial_queue_async(struct fd *fd, void *ptr, unsigned int status, int type, int count)
272 {
273     struct serial *serial = get_fd_user( fd );
274     struct async_queue *q;
275     struct async *async;
276     int timeout;
277
278     assert(serial->obj.ops == &serial_ops);
279
280     switch(type)
281     {
282     case ASYNC_TYPE_READ:
283         q = &serial->read_q;
284         timeout = serial->readconst + serial->readmult*count;
285         break;
286     case ASYNC_TYPE_WAIT:
287         q = &serial->wait_q;
288         timeout = 0;
289         break;
290     case ASYNC_TYPE_WRITE:
291         q = &serial->write_q;
292         timeout = serial->writeconst + serial->writemult*count;
293         break;
294     default:
295         set_error(STATUS_INVALID_PARAMETER);
296         return;
297     }
298
299     async = find_async ( q, current, ptr );
300
301     if ( status == STATUS_PENDING )
302     {
303         int events;
304
305         if ( !async )
306             async = create_async ( &serial->obj, current, ptr );
307         if ( !async )
308             return;
309
310         async->status = STATUS_PENDING;
311         if(!async->q)
312         {
313             async_add_timeout(async,timeout);
314             async_insert(q, async);
315         }
316
317         /* Check if the new pending request can be served immediately */
318         events = check_fd_events( fd, serial_get_poll_events( fd ) );
319         if (events)
320         {
321             /* serial_poll_event() calls set_select_events() */
322             serial_poll_event( fd, events );
323             return;
324         }
325     }
326     else if ( async ) destroy_async ( async );
327     else set_error ( STATUS_INVALID_PARAMETER );
328
329     set_fd_events ( fd, serial_get_poll_events( fd ));
330 }
331
332 static int serial_flush( struct fd *fd )
333 {
334     /* MSDN says: If hFile is a handle to a communications device,
335      * the function only flushes the transmit buffer.
336      */
337     int ret = (tcflush( get_unix_fd(fd), TCOFLUSH ) != -1);
338     if (!ret) file_set_error();
339     return ret;
340 }
341
342 /* create a serial */
343 DECL_HANDLER(create_serial)
344 {
345     struct serial *serial;
346
347     reply->handle = 0;
348     if ((serial = create_serial( get_req_data(), get_req_data_size(), req->access, req->attributes )))
349     {
350         reply->handle = alloc_handle( current->process, serial, req->access, req->inherit );
351         release_object( serial );
352     }
353 }
354
355 DECL_HANDLER(get_serial_info)
356 {
357     struct serial *serial;
358
359     if ((serial = get_serial_obj( current->process, req->handle, 0 )))
360     {
361         /* timeouts */
362         reply->readinterval = serial->readinterval;
363         reply->readconst    = serial->readconst;
364         reply->readmult     = serial->readmult;
365         reply->writeconst   = serial->writeconst;
366         reply->writemult    = serial->writemult;
367
368         /* event mask */
369         reply->eventmask    = serial->eventmask;
370
371         /* comm port error status */
372         reply->commerror    = serial->commerror;
373
374         release_object( serial );
375     }
376 }
377
378 DECL_HANDLER(set_serial_info)
379 {
380     struct serial *serial;
381
382     if ((serial = get_serial_obj( current->process, req->handle, 0 )))
383     {
384         /* timeouts */
385         if(req->flags & SERIALINFO_SET_TIMEOUTS)
386         {
387             serial->readinterval = req->readinterval;
388             serial->readconst    = req->readconst;
389             serial->readmult     = req->readmult;
390             serial->writeconst   = req->writeconst;
391             serial->writemult    = req->writemult;
392         }
393
394         /* event mask */
395         if(req->flags & SERIALINFO_SET_MASK)
396         {
397             serial->eventmask = req->eventmask;
398             if(!serial->eventmask)
399             {
400                 while(serial->wait_q.head)
401                 {
402                     async_notify(serial->wait_q.head, STATUS_SUCCESS);
403                     destroy_async(serial->wait_q.head);
404                 }
405             }
406         }
407
408         /* comm port error status */
409         if(req->flags & SERIALINFO_SET_ERROR)
410         {
411             serial->commerror = req->commerror;
412         }
413
414         release_object( serial );
415     }
416 }