git.oblomov.eu Git - wine/blob - server/serial.c

   1 /*
   2  * Server-side serial port communications management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  * Copyright (C) 2000 Mike McCormack
   6  *
   7  * TODO:
   8  *  Add async read, write and WaitCommEvent handling.
   9  *
  10  */
  11
  12 #include "config.h"
  13
  14 #include <assert.h>
  15 #include <fcntl.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19 #include <errno.h>
  20 #ifdef HAVE_SYS_ERRNO_H
  21 #include <sys/errno.h>
  22 #endif
  23 #include <sys/stat.h>
  24 #include <sys/time.h>
  25 #include <sys/types.h>
  26 #include <time.h>
  27 #include <unistd.h>
  28 #include <utime.h>
  29 #include <termios.h>
  30 #include <sys/ioctl.h>
  31
  32 #include "winerror.h"
  33 #include "winbase.h"
  34
  35 #include "handle.h"
  36 #include "thread.h"
  37 #include "request.h"
  38
  39 static void serial_dump( struct object *obj, int verbose );
  40 static int serial_get_read_fd( struct object *obj );
  41 static int serial_get_write_fd( struct object *obj );
  42 static int serial_get_info( struct object *obj, struct get_file_info_request *req );
  43 static int serial_get_poll_events( struct object *obj );
  44
  45 struct serial
  46 {
  47     struct object       obj;
  48     unsigned int        access;
  49
  50     /* timeout values */
  51     unsigned int        readinterval;
  52     unsigned int        readconst;
  53     unsigned int        readmult;
  54     unsigned int        writeconst;
  55     unsigned int        writemult;
  56
  57     unsigned int        eventmask;
  58     unsigned int        commerror;
  59
  60     struct termios      original;
  61
  62     /* FIXME: add dcb, comm status, handler module, sharing */
  63 };
  64
  65 static const struct object_ops serial_ops =
  66 {
  67     sizeof(struct serial),        /* size */
  68     serial_dump,                  /* dump */
  69     default_poll_add_queue,       /* add_queue */
  70     default_poll_remove_queue,    /* remove_queue */
  71     default_poll_signaled,        /* signaled */
  72     no_satisfied,                 /* satisfied */
  73     serial_get_poll_events,       /* get_poll_events */
  74     default_poll_event,           /* poll_event */
  75     serial_get_read_fd,           /* get_read_fd */
  76     serial_get_write_fd,          /* get_write_fd */
  77     no_flush,                     /* flush */
  78     serial_get_info,              /* get_file_info */
  79     no_destroy                    /* destroy */
  80 };
  81
  82 /* SERIAL PORT functions */
  83
  84 static struct serial *create_serial( const char *nameptr, size_t len, unsigned int access )
  85 {
  86     struct serial *serial;
  87     struct termios tios;
  88     int fd, flags = 0;
  89     char *name;
  90
  91     if (!(name = mem_alloc( len + 1 ))) return NULL;
  92     memcpy( name, nameptr, len );
  93     name[len] = 0;
  94
  95     switch(access & (GENERIC_READ | GENERIC_WRITE))
  96     {
  97     case GENERIC_READ:  flags |= O_RDONLY; break;
  98     case GENERIC_WRITE: flags |= O_WRONLY; break;
  99     case GENERIC_READ|GENERIC_WRITE: flags |= O_RDWR; break;
 100     default: break;
 101     }
 102
 103     fd = open( name, flags );
 104     free( name );
 105     if (fd < 0)
 106     {
 107         file_set_error();
 108         return NULL;
 109     }
 110
 111     /* check its really a serial port */
 112     if (tcgetattr(fd,&tios))
 113     {
 114         file_set_error();
 115         close( fd );
 116         return NULL;
 117     }
 118
 119     if ((serial = alloc_object( &serial_ops, fd )))
 120     {
 121         serial->access       = access;
 122         serial->readinterval = 0;
 123         serial->readmult     = 0;
 124         serial->readconst    = 0;
 125         serial->writemult    = 0;
 126         serial->writeconst   = 0;
 127         serial->eventmask    = 0;
 128         serial->commerror    = 0;
 129     }
 130     return serial;
 131 }
 132
 133 static void serial_dump( struct object *obj, int verbose )
 134 {
 135     struct serial *serial = (struct serial *)obj;
 136     assert( obj->ops == &serial_ops );
 137     fprintf( stderr, "Port fd=%d mask=%x\n", serial->obj.fd, serial->eventmask );
 138 }
 139
 140 struct serial *get_serial_obj( struct process *process, int handle, unsigned int access )
 141 {
 142     return (struct serial *)get_handle_obj( process, handle, access, &serial_ops );
 143 }
 144
 145 static int serial_get_poll_events( struct object *obj )
 146 {
 147     struct serial *serial = (struct serial *)obj;
 148     int events = 0;
 149     assert( obj->ops == &serial_ops );
 150     if (serial->access & GENERIC_READ) events |= POLLIN;
 151     if (serial->access & GENERIC_WRITE) events |= POLLOUT;
 152     return events;
 153 }
 154
 155 static int serial_get_read_fd( struct object *obj )
 156 {
 157     struct serial *serial = (struct serial *)obj;
 158     assert( obj->ops == &serial_ops );
 159     return dup( serial->obj.fd );
 160 }
 161
 162 static int serial_get_write_fd( struct object *obj )
 163 {
 164     struct serial *serial = (struct serial *)obj;
 165     assert( obj->ops == &serial_ops );
 166     return dup( serial->obj.fd );
 167 }
 168
 169 static int serial_get_info( struct object *obj, struct get_file_info_request *req )
 170 {
 171     assert( obj->ops == &serial_ops );
 172     req->type        = FILE_TYPE_CHAR;
 173     req->attr        = 0;
 174     req->access_time = 0;
 175     req->write_time  = 0;
 176     req->size_high   = 0;
 177     req->size_low    = 0;
 178     req->links       = 0;
 179     req->index_high  = 0;
 180     req->index_low   = 0;
 181     req->serial      = 0;
 182     return 1;
 183 }
 184
 185 /* create a serial */
 186 DECL_HANDLER(create_serial)
 187 {
 188     struct serial *serial;
 189
 190     req->handle = -1;
 191     if ((serial = create_serial( get_req_data(req), get_req_data_size(req), req->access )))
 192     {
 193         req->handle = alloc_handle( current->process, serial, req->access, req->inherit );
 194         release_object( serial );
 195     }
 196 }
 197
 198 DECL_HANDLER(get_serial_info)
 199 {
 200     struct serial *serial;
 201
 202     if ((serial = get_serial_obj( current->process, req->handle, 0 )))
 203     {
 204         /* timeouts */
 205         req->readinterval = serial->readinterval;
 206         req->readconst    = serial->readconst;
 207         req->readmult     = serial->readmult;
 208         req->writeconst   = serial->writeconst;
 209         req->writemult    = serial->writemult;
 210
 211         /* event mask */
 212         req->eventmask    = serial->eventmask;
 213
 214         /* comm port error status */
 215         req->commerror    = serial->commerror;
 216
 217         release_object( serial );
 218     }
 219 }
 220
 221 DECL_HANDLER(set_serial_info)
 222 {
 223     struct serial *serial;
 224
 225     if ((serial = get_serial_obj( current->process, req->handle, 0 )))
 226     {
 227         /* timeouts */
 228         if(req->flags & SERIALINFO_SET_TIMEOUTS)
 229         {
 230             serial->readinterval = req->readinterval;
 231             serial->readconst    = req->readconst;
 232             serial->readmult     = req->readmult;
 233             serial->writeconst   = req->writeconst;
 234             serial->writemult    = req->writemult;
 235         }
 236
 237         /* event mask */
 238         if(req->flags & SERIALINFO_SET_MASK)
 239         {
 240             serial->eventmask = req->eventmask;
 241         }
 242
 243         /* comm port error status */
 244         if(req->flags & SERIALINFO_SET_ERROR)
 245         {
 246             serial->commerror = req->commerror;
 247         }
 248
 249         release_object( serial );
 250     }
 251 }
 252