/[rdesktop]/sourceforge.net/trunk/rdesktop/parallel.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /sourceforge.net/trunk/rdesktop/parallel.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 580 by astrand, Fri Jan 23 08:35:52 2004 UTC revision 1365 by jsorg71, Thu Jan 4 05:39:39 2007 UTC
# Line 1  Line 1 
1    /* -*- c-basic-offset: 8 -*-
2       rdesktop: A Remote Desktop Protocol client.
3       Copyright (C) Matthew Chapman 1999-2007
4    
5       This program is free software; you can redistribute it and/or modify
6       it under the terms of the GNU General Public License as published by
7       the Free Software Foundation; either version 2 of the License, or
8       (at your option) any later version.
9    
10       This program is distributed in the hope that it will be useful,
11       but WITHOUT ANY WARRANTY; without even the implied warranty of
12       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13       GNU General Public License for more details.
14    
15       You should have received a copy of the GNU General Public License
16       along with this program; if not, write to the Free Software
17       Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18    */
19  #define MAX_PARALLEL_DEVICES            1  #define MAX_PARALLEL_DEVICES            1
20    
21  #define FILE_DEVICE_PARALLEL            0x22  #define FILE_DEVICE_PARALLEL            0x22
22    
23  #define IOCTL_PAR_QUERY_RAW_DEVICE_ID   0x0c  #define IOCTL_PAR_QUERY_RAW_DEVICE_ID   0x0c
24    
 #define PARALLELDEV0                    "/dev/lp0"  
   
25  #include "rdesktop.h"  #include "rdesktop.h"
26  #include <unistd.h>  #include <unistd.h>
27  #include <fcntl.h>  #include <fcntl.h>
28    #include <sys/ioctl.h>
29    #include <errno.h>
30    
31  extern RDPDR_DEVICE g_rdpdr_device[];  #if defined(__linux__)
32    #include <linux/lp.h>
33    #endif
34    
35  PARALLEL_DEVICE *  extern RDPDR_DEVICE g_rdpdr_device[];
 get_parallel_data(HANDLE handle)  
 {  
         int index;  
   
         for (index = 0; index < RDPDR_MAX_DEVICES; index++)  
         {  
                 if (handle == g_rdpdr_device[index].handle)  
                         return (PARALLEL_DEVICE *) g_rdpdr_device[index].pdevice_data;  
         }  
         return NULL;  
 }  
36    
37    
38  /* Enumeration of devices from rdesktop.c        */  /* Enumeration of devices from rdesktop.c        */
# Line 31  get_parallel_data(HANDLE handle) Line 40  get_parallel_data(HANDLE handle)
40  /* optarg looks like ':LPT1=/dev/lp0'            */  /* optarg looks like ':LPT1=/dev/lp0'            */
41  /* when it arrives to this function.             */  /* when it arrives to this function.             */
42  int  int
43  parallel_enum_devices(int *id, char *optarg)  parallel_enum_devices(uint32 * id, char *optarg)
44  {  {
         //TODO: Read from configuration file? CUPS?  
45          PARALLEL_DEVICE *ppar_info;          PARALLEL_DEVICE *ppar_info;
46    
47          char *pos = optarg;          char *pos = optarg;
48          char *pos2;          char *pos2;
49          int count = 0;          int count = 0;
50    
51          // skip the first colon          /* skip the first colon */
52          optarg++;          optarg++;
53          while ((pos = next_arg(optarg, ',')) && *id < RDPDR_MAX_DEVICES)          while ((pos = next_arg(optarg, ',')) && *id < RDPDR_MAX_DEVICES)
54          {          {
# Line 55  parallel_enum_devices(int *id, char *opt Line 63  parallel_enum_devices(int *id, char *opt
63                  strcpy(g_rdpdr_device[*id].local_path, pos2);                  strcpy(g_rdpdr_device[*id].local_path, pos2);
64                  printf("PARALLEL %s to %s\n", optarg, pos2);                  printf("PARALLEL %s to %s\n", optarg, pos2);
65    
66                  // set device type                  /* set device type */
67                  g_rdpdr_device[*id].device_type = DEVICE_TYPE_PARALLEL;                  g_rdpdr_device[*id].device_type = DEVICE_TYPE_PARALLEL;
68                  g_rdpdr_device[*id].pdevice_data = (void *) ppar_info;                  g_rdpdr_device[*id].pdevice_data = (void *) ppar_info;
69                    g_rdpdr_device[*id].handle = 0;
70                  count++;                  count++;
71                  (*id)++;                  (*id)++;
72    
# Line 66  parallel_enum_devices(int *id, char *opt Line 75  parallel_enum_devices(int *id, char *opt
75          return count;          return count;
76  }  }
77    
78  static NTSTATUS  static RD_NTSTATUS
79  parallel_create(uint32 device_id, HANDLE * handle)  parallel_create(uint32 device_id, uint32 access, uint32 share_mode, uint32 disposition,
80                    uint32 flags, char *filename, RD_NTHANDLE * handle)
81  {  {
82          int parallel_fd;          int parallel_fd;
83    
84          parallel_fd = open(PARALLELDEV0, O_WRONLY);          parallel_fd = open(g_rdpdr_device[device_id].local_path, O_RDWR);
85          if (parallel_fd == -1)          if (parallel_fd == -1)
86                  return STATUS_ACCESS_DENIED;          {
87                    perror("open");
88                    return RD_STATUS_ACCESS_DENIED;
89            }
90    
91            /* all read and writes should be non blocking */
92            if (fcntl(parallel_fd, F_SETFL, O_NONBLOCK) == -1)
93                    perror("fcntl");
94    
95    #if defined(LPABORT)
96            /* Retry on errors */
97            ioctl(parallel_fd, LPABORT, (int) 1);
98    #endif
99    
100            g_rdpdr_device[device_id].handle = parallel_fd;
101    
102          *handle = parallel_fd;          *handle = parallel_fd;
103          return STATUS_SUCCESS;  
104            return RD_STATUS_SUCCESS;
105  }  }
106    
107  static NTSTATUS  static RD_NTSTATUS
108  parallel_close(HANDLE handle)  parallel_close(RD_NTHANDLE handle)
109  {  {
110            int i = get_device_index(handle);
111            if (i >= 0)
112                    g_rdpdr_device[i].handle = 0;
113          close(handle);          close(handle);
114          return STATUS_SUCCESS;          return RD_STATUS_SUCCESS;
115  }  }
116    
117  static NTSTATUS  static RD_NTSTATUS
118  parallel_write(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)  parallel_read(RD_NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
119  {  {
120          *result = write(handle, data, length);          *result = read(handle, data, length);
121          return STATUS_SUCCESS;          return RD_STATUS_SUCCESS;
122    }
123    
124    static RD_NTSTATUS
125    parallel_write(RD_NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
126    {
127            int rc = RD_STATUS_SUCCESS;
128    
129            int n = write(handle, data, length);
130            if (n < 0)
131            {
132    #if defined(LPGETSTATUS)
133                    int status;
134    #endif
135    
136                    *result = 0;
137                    switch (errno)
138                    {
139                            case EAGAIN:
140                                    rc = RD_STATUS_DEVICE_OFF_LINE;
141                            case ENOSPC:
142                                    rc = RD_STATUS_DEVICE_PAPER_EMPTY;
143                            case EIO:
144                                    rc = RD_STATUS_DEVICE_OFF_LINE;
145                            default:
146                                    rc = RD_STATUS_DEVICE_POWERED_OFF;
147                    }
148    #if defined(LPGETSTATUS)
149                    if (ioctl(handle, LPGETSTATUS, &status) == 0)
150                    {
151                            /* coming soon: take care for the printer status */
152                            printf("parallel_write: status = %d, errno = %d\n", status, errno);
153                    }
154    #endif
155            }
156            *result = n;
157            return rc;
158  }  }
159    
160  static NTSTATUS  static RD_NTSTATUS
161  parallel_device_control(HANDLE handle, uint32 request, STREAM in, STREAM out)  parallel_device_control(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out)
162  {  {
163          if ((request >> 16) != FILE_DEVICE_PARALLEL)          if ((request >> 16) != FILE_DEVICE_PARALLEL)
164                  return STATUS_INVALID_PARAMETER;                  return RD_STATUS_INVALID_PARAMETER;
165    
166          /* extract operation */          /* extract operation */
167          request >>= 2;          request >>= 2;
# Line 114  parallel_device_control(HANDLE handle, u Line 178  parallel_device_control(HANDLE handle, u
178                          printf("\n");                          printf("\n");
179                          unimpl("UNKNOWN IOCTL %d\n", request);                          unimpl("UNKNOWN IOCTL %d\n", request);
180          }          }
181          return STATUS_SUCCESS;          return RD_STATUS_SUCCESS;
182  }  }
183    
184  DEVICE_FNS parallel_fns = {  DEVICE_FNS parallel_fns = {
185          parallel_create,          parallel_create,
186          parallel_close,          parallel_close,
187          NULL,          parallel_read,
188          parallel_write,          parallel_write,
189          parallel_device_control          parallel_device_control
190  };  };
Legend:
Removed from v.580  
changed lines
  Added in v.1365
  ViewVC Help
Powered by ViewVC 1.1.26