/[rdesktop]/sourceforge.net/trunk/rdesktop/rdpdr.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/rdpdr.c

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

revision 1328 by stargo, Fri Nov 3 23:51:35 2006 UTC revision 1364 by jsorg71, Thu Jan 4 04:55:56 2007 UTC
# Line 69  extern BOOL g_notify_stamp; Line 69  extern BOOL g_notify_stamp;
69  static VCHANNEL *rdpdr_channel;  static VCHANNEL *rdpdr_channel;
70    
71  /* If select() times out, the request for the device with handle g_min_timeout_fd is aborted */  /* If select() times out, the request for the device with handle g_min_timeout_fd is aborted */
72  NTHANDLE g_min_timeout_fd;  RD_NTHANDLE g_min_timeout_fd;
73  uint32 g_num_devices;  uint32 g_num_devices;
74    
75  /* Table with information about rdpdr devices */  /* Table with information about rdpdr devices */
# Line 94  struct async_iorequest *g_iorequest; Line 94  struct async_iorequest *g_iorequest;
94    
95  /* Return device_id for a given handle */  /* Return device_id for a given handle */
96  int  int
97  get_device_index(NTHANDLE handle)  get_device_index(RD_NTHANDLE handle)
98  {  {
99          int i;          int i;
100          for (i = 0; i < RDPDR_MAX_DEVICES; i++)          for (i = 0; i < RDPDR_MAX_DEVICES; i++)
# Line 366  rdpdr_process_irp(STREAM s) Line 366  rdpdr_process_irp(STREAM s)
366          struct stream out;          struct stream out;
367          DEVICE_FNS *fns;          DEVICE_FNS *fns;
368          BOOL rw_blocking = True;          BOOL rw_blocking = True;
369          NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;          RD_NTSTATUS status = RD_STATUS_INVALID_DEVICE_REQUEST;
370    
371          in_uint32_le(s, device);          in_uint32_le(s, device);
372          in_uint32_le(s, file);          in_uint32_le(s, file);
# Line 439  rdpdr_process_irp(STREAM s) Line 439  rdpdr_process_irp(STREAM s)
439    
440                          if (!fns->create)                          if (!fns->create)
441                          {                          {
442                                  status = STATUS_NOT_SUPPORTED;                                  status = RD_STATUS_NOT_SUPPORTED;
443                                  break;                                  break;
444                          }                          }
445    
# Line 451  rdpdr_process_irp(STREAM s) Line 451  rdpdr_process_irp(STREAM s)
451                  case IRP_MJ_CLOSE:                  case IRP_MJ_CLOSE:
452                          if (!fns->close)                          if (!fns->close)
453                          {                          {
454                                  status = STATUS_NOT_SUPPORTED;                                  status = RD_STATUS_NOT_SUPPORTED;
455                                  break;                                  break;
456                          }                          }
457    
# Line 462  rdpdr_process_irp(STREAM s) Line 462  rdpdr_process_irp(STREAM s)
462    
463                          if (!fns->read)                          if (!fns->read)
464                          {                          {
465                                  status = STATUS_NOT_SUPPORTED;                                  status = RD_STATUS_NOT_SUPPORTED;
466                                  break;                                  break;
467                          }                          }
468    
# Line 473  rdpdr_process_irp(STREAM s) Line 473  rdpdr_process_irp(STREAM s)
473  #endif  #endif
474                          if (!rdpdr_handle_ok(device, file))                          if (!rdpdr_handle_ok(device, file))
475                          {                          {
476                                  status = STATUS_INVALID_HANDLE;                                  status = RD_STATUS_INVALID_HANDLE;
477                                  break;                                  break;
478                          }                          }
479    
# Line 482  rdpdr_process_irp(STREAM s) Line 482  rdpdr_process_irp(STREAM s)
482                                  buffer = (uint8 *) xrealloc((void *) buffer, length);                                  buffer = (uint8 *) xrealloc((void *) buffer, length);
483                                  if (!buffer)                                  if (!buffer)
484                                  {                                  {
485                                          status = STATUS_CANCELLED;                                          status = RD_STATUS_CANCELLED;
486                                          break;                                          break;
487                                  }                                  }
488                                  status = fns->read(file, buffer, length, offset, &result);                                  status = fns->read(file, buffer, length, offset, &result);
# Line 494  rdpdr_process_irp(STREAM s) Line 494  rdpdr_process_irp(STREAM s)
494                          pst_buf = (uint8 *) xmalloc(length);                          pst_buf = (uint8 *) xmalloc(length);
495                          if (!pst_buf)                          if (!pst_buf)
496                          {                          {
497                                  status = STATUS_CANCELLED;                                  status = RD_STATUS_CANCELLED;
498                                  break;                                  break;
499                          }                          }
500                          serial_get_timeout(file, length, &total_timeout, &interval_timeout);                          serial_get_timeout(file, length, &total_timeout, &interval_timeout);
# Line 502  rdpdr_process_irp(STREAM s) Line 502  rdpdr_process_irp(STREAM s)
502                              (device, file, id, major, length, fns, total_timeout, interval_timeout,                              (device, file, id, major, length, fns, total_timeout, interval_timeout,
503                               pst_buf, offset))                               pst_buf, offset))
504                          {                          {
505                                  status = STATUS_PENDING;                                  status = RD_STATUS_PENDING;
506                                  break;                                  break;
507                          }                          }
508    
509                          status = STATUS_CANCELLED;                          status = RD_STATUS_CANCELLED;
510                          break;                          break;
511                  case IRP_MJ_WRITE:                  case IRP_MJ_WRITE:
512    
# Line 514  rdpdr_process_irp(STREAM s) Line 514  rdpdr_process_irp(STREAM s)
514    
515                          if (!fns->write)                          if (!fns->write)
516                          {                          {
517                                  status = STATUS_NOT_SUPPORTED;                                  status = RD_STATUS_NOT_SUPPORTED;
518                                  break;                                  break;
519                          }                          }
520    
# Line 526  rdpdr_process_irp(STREAM s) Line 526  rdpdr_process_irp(STREAM s)
526  #endif  #endif
527                          if (!rdpdr_handle_ok(device, file))                          if (!rdpdr_handle_ok(device, file))
528                          {                          {
529                                  status = STATUS_INVALID_HANDLE;                                  status = RD_STATUS_INVALID_HANDLE;
530                                  break;                                  break;
531                          }                          }
532    
# Line 540  rdpdr_process_irp(STREAM s) Line 540  rdpdr_process_irp(STREAM s)
540                          pst_buf = (uint8 *) xmalloc(length);                          pst_buf = (uint8 *) xmalloc(length);
541                          if (!pst_buf)                          if (!pst_buf)
542                          {                          {
543                                  status = STATUS_CANCELLED;                                  status = RD_STATUS_CANCELLED;
544                                  break;                                  break;
545                          }                          }
546    
# Line 549  rdpdr_process_irp(STREAM s) Line 549  rdpdr_process_irp(STREAM s)
549                          if (add_async_iorequest                          if (add_async_iorequest
550                              (device, file, id, major, length, fns, 0, 0, pst_buf, offset))                              (device, file, id, major, length, fns, 0, 0, pst_buf, offset))
551                          {                          {
552                                  status = STATUS_PENDING;                                  status = RD_STATUS_PENDING;
553                                  break;                                  break;
554                          }                          }
555    
556                          status = STATUS_CANCELLED;                          status = RD_STATUS_CANCELLED;
557                          break;                          break;
558    
559                  case IRP_MJ_QUERY_INFORMATION:                  case IRP_MJ_QUERY_INFORMATION:
560    
561                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
562                          {                          {
563                                  status = STATUS_INVALID_HANDLE;                                  status = RD_STATUS_INVALID_HANDLE;
564                                  break;                                  break;
565                          }                          }
566                          in_uint32_le(s, info_level);                          in_uint32_le(s, info_level);
# Line 576  rdpdr_process_irp(STREAM s) Line 576  rdpdr_process_irp(STREAM s)
576    
577                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
578                          {                          {
579                                  status = STATUS_INVALID_HANDLE;                                  status = RD_STATUS_INVALID_HANDLE;
580                                  break;                                  break;
581                          }                          }
582    
# Line 592  rdpdr_process_irp(STREAM s) Line 592  rdpdr_process_irp(STREAM s)
592    
593                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
594                          {                          {
595                                  status = STATUS_INVALID_HANDLE;                                  status = RD_STATUS_INVALID_HANDLE;
596                                  break;                                  break;
597                          }                          }
598    
# Line 608  rdpdr_process_irp(STREAM s) Line 608  rdpdr_process_irp(STREAM s)
608    
609                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
610                          {                          {
611                                  status = STATUS_INVALID_HANDLE;                                  status = RD_STATUS_INVALID_HANDLE;
612                                  break;                                  break;
613                          }                          }
614    
# Line 650  rdpdr_process_irp(STREAM s) Line 650  rdpdr_process_irp(STREAM s)
650                                          status = disk_create_notify(file, info_level);                                          status = disk_create_notify(file, info_level);
651                                          result = 0;                                          result = 0;
652    
653                                          if (status == STATUS_PENDING)                                          if (status == RD_STATUS_PENDING)
654                                                  add_async_iorequest(device, file, id, major, length,                                                  add_async_iorequest(device, file, id, major, length,
655                                                                      fns, 0, 0, NULL, 0);                                                                      fns, 0, 0, NULL, 0);
656                                          break;                                          break;
657    
658                                  default:                                  default:
659    
660                                          status = STATUS_INVALID_PARAMETER;                                          status = RD_STATUS_INVALID_PARAMETER;
661                                          /* JIF */                                          /* JIF */
662                                          unimpl("IRP major=0x%x minor=0x%x\n", major, minor);                                          unimpl("IRP major=0x%x minor=0x%x\n", major, minor);
663                          }                          }
# Line 667  rdpdr_process_irp(STREAM s) Line 667  rdpdr_process_irp(STREAM s)
667    
668                          if (!fns->device_control)                          if (!fns->device_control)
669                          {                          {
670                                  status = STATUS_NOT_SUPPORTED;                                  status = RD_STATUS_NOT_SUPPORTED;
671                                  break;                                  break;
672                          }                          }
673    
# Line 679  rdpdr_process_irp(STREAM s) Line 679  rdpdr_process_irp(STREAM s)
679                          buffer = (uint8 *) xrealloc((void *) buffer, bytes_out + 0x14);                          buffer = (uint8 *) xrealloc((void *) buffer, bytes_out + 0x14);
680                          if (!buffer)                          if (!buffer)
681                          {                          {
682                                  status = STATUS_CANCELLED;                                  status = RD_STATUS_CANCELLED;
683                                  break;                                  break;
684                          }                          }
685    
# Line 699  rdpdr_process_irp(STREAM s) Line 699  rdpdr_process_irp(STREAM s)
699                          DEBUG_SCARD(("[SMART-CARD TRACE] OUT 0x%.8x\n", status));                          DEBUG_SCARD(("[SMART-CARD TRACE] OUT 0x%.8x\n", status));
700    
701                          /* Serial SERIAL_WAIT_ON_MASK */                          /* Serial SERIAL_WAIT_ON_MASK */
702                          if (status == STATUS_PENDING)                          if (status == RD_STATUS_PENDING)
703                          {                          {
704                                  if (add_async_iorequest                                  if (add_async_iorequest
705                                      (device, file, id, major, length, fns, 0, 0, NULL, 0))                                      (device, file, id, major, length, fns, 0, 0, NULL, 0))
706                                  {                                  {
707                                          status = STATUS_PENDING;                                          status = RD_STATUS_PENDING;
708                                          break;                                          break;
709                                  }                                  }
710                          }                          }
711  #ifdef WITH_SCARD  #ifdef WITH_SCARD
712                          else if (status == (STATUS_PENDING | 0xC0000000))                          else if (status == (RD_STATUS_PENDING | 0xC0000000))
713                                  status = STATUS_PENDING;                                  status = RD_STATUS_PENDING;
714  #endif  #endif
715                          break;                          break;
716    
# Line 719  rdpdr_process_irp(STREAM s) Line 719  rdpdr_process_irp(STREAM s)
719    
720                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)                          if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
721                          {                          {
722                                  status = STATUS_INVALID_HANDLE;                                  status = RD_STATUS_INVALID_HANDLE;
723                                  break;                                  break;
724                          }                          }
725    
# Line 729  rdpdr_process_irp(STREAM s) Line 729  rdpdr_process_irp(STREAM s)
729                          out.size = sizeof(buffer);                          out.size = sizeof(buffer);
730                          /* FIXME: Perhaps consider actually *do*                          /* FIXME: Perhaps consider actually *do*
731                             something here :-) */                             something here :-) */
732                          status = STATUS_SUCCESS;                          status = RD_STATUS_SUCCESS;
733                          result = buffer_len = out.p - out.data;                          result = buffer_len = out.p - out.data;
734                          break;                          break;
735    
# Line 738  rdpdr_process_irp(STREAM s) Line 738  rdpdr_process_irp(STREAM s)
738                          break;                          break;
739          }          }
740    
741          if (status != STATUS_PENDING)          if (status != RD_STATUS_PENDING)
742          {          {
743                  rdpdr_send_completion(device, id, status, result, buffer, buffer_len);                  rdpdr_send_completion(device, id, status, result, buffer, buffer_len);
744          }          }
# Line 960  rdpdr_remove_iorequest(struct async_iore Line 960  rdpdr_remove_iorequest(struct async_iore
960  static void  static void
961  _rdpdr_check_fds(fd_set * rfds, fd_set * wfds, BOOL timed_out)  _rdpdr_check_fds(fd_set * rfds, fd_set * wfds, BOOL timed_out)
962  {  {
963          NTSTATUS status;          RD_NTSTATUS status;
964          uint32 result = 0;          uint32 result = 0;
965          DEVICE_FNS *fns;          DEVICE_FNS *fns;
966          struct async_iorequest *iorq;          struct async_iorequest *iorq;
# Line 989  _rdpdr_check_fds(fd_set * rfds, fd_set * Line 989  _rdpdr_check_fds(fd_set * rfds, fd_set *
989                                          /* iv_timeout between 2 chars, send partial_len */                                          /* iv_timeout between 2 chars, send partial_len */
990                                          /*printf("RDPDR: IVT total %u bytes read of %u\n", iorq->partial_len, iorq->length); */                                          /*printf("RDPDR: IVT total %u bytes read of %u\n", iorq->partial_len, iorq->length); */
991                                          rdpdr_send_completion(iorq->device,                                          rdpdr_send_completion(iorq->device,
992                                                                iorq->id, STATUS_SUCCESS,                                                                iorq->id, RD_STATUS_SUCCESS,
993                                                                iorq->partial_len,                                                                iorq->partial_len,
994                                                                iorq->buffer, iorq->partial_len);                                                                iorq->buffer, iorq->partial_len);
995                                          iorq = rdpdr_remove_iorequest(prev, iorq);                                          iorq = rdpdr_remove_iorequest(prev, iorq);
# Line 1013  _rdpdr_check_fds(fd_set * rfds, fd_set * Line 1013  _rdpdr_check_fds(fd_set * rfds, fd_set *
1013    
1014                  }                  }
1015    
1016                  rdpdr_abort_io(g_min_timeout_fd, 0, STATUS_TIMEOUT);                  rdpdr_abort_io(g_min_timeout_fd, 0, RD_STATUS_TIMEOUT);
1017                  return;                  return;
1018          }          }
1019    
# Line 1117  _rdpdr_check_fds(fd_set * rfds, fd_set * Line 1117  _rdpdr_check_fds(fd_set * rfds, fd_set *
1117                                                  out.size = sizeof(buffer);                                                  out.size = sizeof(buffer);
1118                                                  out_uint32_le(&out, result);                                                  out_uint32_le(&out, result);
1119                                                  result = buffer_len = out.p - out.data;                                                  result = buffer_len = out.p - out.data;
1120                                                  status = STATUS_SUCCESS;                                                  status = RD_STATUS_SUCCESS;
1121                                                  rdpdr_send_completion(iorq->device, iorq->id,                                                  rdpdr_send_completion(iorq->device, iorq->id,
1122                                                                        status, result, buffer,                                                                        status, result, buffer,
1123                                                                        buffer_len);                                                                        buffer_len);
# Line 1153  _rdpdr_check_fds(fd_set * rfds, fd_set * Line 1153  _rdpdr_check_fds(fd_set * rfds, fd_set *
1153                                                  {                                                  {
1154                                                          g_notify_stamp = False;                                                          g_notify_stamp = False;
1155                                                          status = disk_check_notify(iorq->fd);                                                          status = disk_check_notify(iorq->fd);
1156                                                          if (status != STATUS_PENDING)                                                          if (status != RD_STATUS_PENDING)
1157                                                          {                                                          {
1158                                                                  rdpdr_send_completion(iorq->device,                                                                  rdpdr_send_completion(iorq->device,
1159                                                                                        iorq->id,                                                                                        iorq->id,
# Line 1198  rdpdr_check_fds(fd_set * rfds, fd_set * Line 1198  rdpdr_check_fds(fd_set * rfds, fd_set *
1198    
1199  /* Abort a pending io request for a given handle and major */  /* Abort a pending io request for a given handle and major */
1200  BOOL  BOOL
1201  rdpdr_abort_io(uint32 fd, uint32 major, NTSTATUS status)  rdpdr_abort_io(uint32 fd, uint32 major, RD_NTSTATUS status)
1202  {  {
1203          uint32 result;          uint32 result;
1204          struct async_iorequest *iorq;          struct async_iorequest *iorq;
Legend:
Removed from v.1328  
changed lines
  Added in v.1364
  ViewVC Help
Powered by ViewVC 1.1.26