home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / kernex32.zip / mwdd_src.zip / 32bits / ext2-os2 / mwdd32 / mwdd32_ioctl.c < prev    next >
C/C++ Source or Header  |  1997-03-16  |  14KB  |  284 lines
  1. //
  2. // $Header: d:\\32bits\\ext2-os2\\mwdd32\\rcs\\mwdd32_ioctl.c,v 1.6 1997/03/16 12:44:29 Willm Exp $
  3. //
  4.  
  5. // 32 bits OS/2 device driver and IFS support. Provides 32 bits kernel 
  6. // services (DevHelp) and utility functions to 32 bits OS/2 ring 0 code 
  7. // (device drivers and installable file system drivers).
  8. // Copyright (C) 1995, 1996, 1997  Matthieu WILLM (willm@ibm.net)
  9. //
  10. // This program is free software; you can redistribute it and/or modify
  11. // it under the terms of the GNU General Public License as published by
  12. // the Free Software Foundation; either version 2 of the License, or
  13. // (at your option) any later version.
  14. //
  15. // This program is distributed in the hope that it will be useful,
  16. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. // GNU General Public License for more details.
  19. //
  20. // You should have received a copy of the GNU General Public License
  21. // along with this program; if not, write to the Free Software
  22. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  
  24. #define INCL_DOS
  25. #define INCL_DOSERRORS
  26. #define INCL_NOPMAPI
  27. #include <os2.h>
  28.  
  29. #include <os2/types.h>
  30. #include <os2/StackToFlat.h>
  31. #include <os2/DevHlp32.h>
  32. #include <reqpkt32.h>
  33. #include <mwdd32_ioctl.h>
  34.  
  35. #include "mwdd32_entry_points.h"
  36. #include "mwdd32.h"
  37.  
  38. struct DevHelp32 DevHlp32 = {
  39.     DEVHELP32_MAGIC,
  40.     DEVHELP32_VERSION,
  41.     {
  42.         DevHlp32_SaveMessage,
  43.         DevHlp32_InternalError,
  44.         DevHlp32_VMAlloc,
  45.         DevHlp32_VMFree,
  46.         DevHlp32_VMLock,
  47.         DevHlp32_VMUnlock,
  48.         DevHlp32_VirtToLin,
  49.         DevHlp32_ProcBlock,
  50.         DevHlp32_ProcRun,
  51.         DevHlp32_LinToPageList,
  52.         DevHlp32_Security,
  53.         DevHlp32_Yield,
  54.         DevHlp32_GetInfoSegs,
  55.     vsprintf,
  56.         __mwdd32_strtoul,
  57.         __mwdd32_atol,
  58.         __mwdd32_strupr,
  59.         __mwdd32_strpbrk,
  60.         __mwdd32_fnmatch,
  61.         __mwdd32_strtol,
  62.     sec32_attach_ses,
  63.     DevHlp32_setIRQ,
  64.     DevHlp32_EOI,
  65.     DevHlp32_UnSetIRQ,
  66.     DevHlp32_PageListToLin,
  67.     DevHlp32_AllocGDTSelector,
  68.         DevHlp32_FreeGDTSelector,
  69.         DevHlp32_AttachDD,
  70.         DevHlp32_GetDosVar,
  71.     DevHlp32_VerifyAccess,
  72.     DevHlp32_CloseEventSem,
  73.     DevHlp32_OpenEventSem,
  74.     DevHlp32_PostEventSem,
  75.     DevHlp32_ResetEventSem
  76.     }
  77. };
  78.  
  79. int mwdd32_ioctl(PTR16 reqpkt) {
  80.     int                  rc;
  81.     int                  status ;
  82.     struct reqpkt_ioctl *request;
  83.     void                *parm;
  84.     void                *data;
  85.     char                 lock_parm[12];
  86.     char                 lock_data[12];
  87.     ULONG                PgCount;
  88.  
  89.     status = 0;
  90.     if ((rc = DevHlp32_VirtToLin(reqpkt, __StackToFlat(&request))) == NO_ERROR) {
  91.         if (request->cat == MWDD32_IOCTL_CATEGORY) {
  92.             switch(request->func) {
  93.                 /*
  94.                  * Calls an IFS's fs32_init() entry point at ring 0
  95.                  */
  96.                 case MWDD32_IOCTL_FUNCTION_INIT_FSD :
  97.                     if ((rc = DevHlp32_VirtToLin(request->parm, __StackToFlat(&parm))) == NO_ERROR) {
  98.                         if ((rc = DevHlp32_VirtToLin(request->data, __StackToFlat(&data))) == NO_ERROR) {
  99.                             rc = DevHlp32_VMLock(VMDHL_WRITE | VMDHL_LONG | VMDHL_VERIFY, parm, sizeof(union mwdd32_ioctl_int_fsd_parm), (void *)-1, __StackToFlat(lock_parm), __StackToFlat(&PgCount));
  100.                             if ((rc == NO_ERROR) || (rc == ERROR_NOBLOCK)) {
  101.                                 rc = DevHlp32_VMLock(VMDHL_WRITE | VMDHL_LONG | VMDHL_VERIFY, data, sizeof(union mwdd32_ioctl_int_fsd_data), (void *)-1, __StackToFlat(lock_data), __StackToFlat(&PgCount));
  102.                                 if ((rc == NO_ERROR) || (rc == ERROR_NOBLOCK)) {
  103.                                     /*
  104.                                      * OK now we can safely access both parm and data
  105.                                      */
  106.                                     union mwdd32_ioctl_int_fsd_parm *pparm = (union mwdd32_ioctl_int_fsd_parm *)parm;
  107.                                     union mwdd32_ioctl_int_fsd_data *pdata = (union mwdd32_ioctl_int_fsd_data *)data;
  108.  
  109.  
  110.                                     if (pparm->input.magic_in == INIT_FSD_MAGIC_IN) {
  111.                                         void *fs32_init_parms;
  112.                                         if ((rc = DevHlp32_VirtToLin(pdata->input.fs32_init_parms, __StackToFlat(&fs32_init_parms))) == NO_ERROR) {
  113.                                             if ((rc = (int)mwdd32_export_devhelp32(pdata->input.pTKSSBase, pdata->input.pDevHelp32)) == NO_ERROR) {
  114.                                                 pparm->output.magic_out    = INIT_FSD_MAGIC_OUT;
  115.                                                 pdata->output.fs32_init_rc = pdata->input.fs32_init(fs32_init_parms);
  116.                                             } else {
  117.                                                 pparm->output.magic_out     = INIT_FSD_MAGIC_OUT;
  118.                                                 pdata->output.fs32_init_rc  = 0;
  119.                                                 status                     |=  STERR + ERROR_I24_INVALID_PARAMETER;
  120.                                             }
  121.                                         } else {
  122.                                             pparm->output.magic_out     = INIT_FSD_MAGIC_OUT;
  123.                                             pdata->output.fs32_init_rc  = rc;
  124.                                             status                     |=  STERR + ERROR_I24_INVALID_PARAMETER;
  125.  
  126.                                         }
  127.                                     } else {
  128.                                         pparm->output.magic_out    = INIT_FSD_MAGIC_OUT;
  129.                                         pdata->output.fs32_init_rc = ERROR_INVALID_PARAMETER;
  130.                                         status                    |=  STERR + ERROR_I24_INVALID_PARAMETER;
  131.                                     }
  132.  
  133.                                     if ((rc = DevHlp32_VMUnlock(__StackToFlat(lock_data))) == NO_ERROR) {
  134.                                         /*
  135.                                          * no special processing here
  136.                                          */
  137.                                     } else {
  138.                                         /*
  139.                                          * error while unlocking request->data
  140.                                          */
  141.                                         status |=  STERR + ERROR_I24_GEN_FAILURE;
  142.                                     }
  143.                                 } else {
  144.                                     /*
  145.                                      * error while locking request->data
  146.                                      */
  147.                                     status |= STERR + ERROR_I24_INVALID_PARAMETER;
  148.                                 }
  149.                                 if ((rc = DevHlp32_VMUnlock(__StackToFlat(lock_parm))) == NO_ERROR) {
  150.                                     /*
  151.                                      * no special processing
  152.                                      */
  153.                                 } else {
  154.                                     /*
  155.                                      * error while unlocking request->parm
  156.                                      */
  157.                                    status |= STERR + ERROR_I24_GEN_FAILURE;
  158.                                 }
  159.                             } else {
  160.                                 /*
  161.                                  * error while locking request->parm
  162.                                  */
  163.                                 status |= STERR + ERROR_I24_INVALID_PARAMETER;
  164.                             }
  165.                         } else {
  166.                             /*
  167.                              * error while thunking request->data
  168.                              */
  169.                             status |= STERR + ERROR_I24_INVALID_PARAMETER;
  170.                         }
  171.                     } else {
  172.                         /*
  173.                          * error while thunking request->parm
  174.                          */
  175.                         status |= STERR + ERROR_I24_INVALID_PARAMETER;
  176.                     }
  177.                     break;
  178.  
  179.  
  180.  
  181.  
  182.  
  183.  
  184.                 /*
  185.                  * Calls an DEVICE device driver device_init() entry point at ring 0
  186.                  */
  187.                 case MWDD32_IOCTL_FUNCTION_INIT_DEVICE :
  188.                     if ((rc = DevHlp32_VirtToLin(request->parm, __StackToFlat(&parm))) == NO_ERROR) {
  189.                         if ((rc = DevHlp32_VirtToLin(request->data, __StackToFlat(&data))) == NO_ERROR) {
  190.                             rc = DevHlp32_VMLock(VMDHL_WRITE | VMDHL_LONG | VMDHL_VERIFY, parm, sizeof(union mwdd32_ioctl_int_fsd_parm), (void *)-1, __StackToFlat(lock_parm), __StackToFlat(&PgCount));
  191.                             if ((rc == NO_ERROR) || (rc == ERROR_NOBLOCK)) {
  192.                                 rc = DevHlp32_VMLock(VMDHL_WRITE | VMDHL_LONG | VMDHL_VERIFY, data, sizeof(union mwdd32_ioctl_int_fsd_data), (void *)-1, __StackToFlat(lock_data), __StackToFlat(&PgCount));
  193.                                 if ((rc == NO_ERROR) || (rc == ERROR_NOBLOCK)) {
  194.                                     /*
  195.                                      * OK now we can safely access both parm and data
  196.                                      */
  197.                                     union mwdd32_ioctl_init_device_parm *pparm = (union mwdd32_ioctl_init_device_parm *)parm;
  198.                                     union mwdd32_ioctl_init_device_data *pdata = (union mwdd32_ioctl_init_device_data *)data;
  199.  
  200.  
  201.                                     if (pparm->input.magic_in == INIT_DEVICE_MAGIC_IN) {
  202.                                         if ((rc = (int)mwdd32_export_devhelp32(pdata->input.pTKSSBase, pdata->input.pDevHelp32)) == NO_ERROR) {
  203.                                             pparm->output.magic_out      = INIT_DEVICE_MAGIC_OUT;
  204.                                             pdata->output.device_init_rc = pdata->input.device_init(pdata->input.reqpkt);
  205.                                         } else {
  206.                                             pparm->output.magic_out       = INIT_DEVICE_MAGIC_OUT;
  207.                                             pdata->output.device_init_rc  = 0;
  208.                                             status                       |=  STERR + ERROR_I24_INVALID_PARAMETER;
  209.                                         }
  210.                                     } else {
  211.                                         pparm->output.magic_out      = INIT_DEVICE_MAGIC_OUT;
  212.                                         pdata->output.device_init_rc = ERROR_INVALID_PARAMETER;
  213.                                         status                      |= STERR + ERROR_I24_INVALID_PARAMETER;
  214.                                     }
  215.  
  216.                                     if ((rc = DevHlp32_VMUnlock(__StackToFlat(lock_data))) == NO_ERROR) {
  217.                                         /*
  218.                                          * no special processing here
  219.                                          */
  220.                                     } else {
  221.                                         /*
  222.                                          * error while unlocking request->data
  223.                                          */
  224.                                         status |=  STERR + ERROR_I24_GEN_FAILURE;
  225.                                     }
  226.                                 } else {
  227.                                     /*
  228.                                      * error while locking request->data
  229.                                      */
  230.                                     status |= STERR + ERROR_I24_INVALID_PARAMETER;
  231.                                 }
  232.                                 if ((rc = DevHlp32_VMUnlock(__StackToFlat(lock_parm))) == NO_ERROR) {
  233.                                     /*
  234.                                      * no special processing
  235.                                      */
  236.                                 } else {
  237.                                     /*
  238.                                      * error while unlocking request->parm
  239.                                      */
  240.                                    status |= STERR + ERROR_I24_GEN_FAILURE;
  241.                                 }
  242.                             } else {
  243.                                 /*
  244.                                  * error while locking request->parm
  245.                                  */
  246.                                 status |= STERR + ERROR_I24_INVALID_PARAMETER;
  247.                             }
  248.                         } else {
  249.                             /*
  250.                              * error while thunking request->data
  251.                              */
  252.                             status |= STERR + ERROR_I24_INVALID_PARAMETER;
  253.                         }
  254.                     } else {
  255.                         /*
  256.                          * error while thunking request->parm
  257.                          */
  258.                         status |= STERR + ERROR_I24_INVALID_PARAMETER;
  259.                     }
  260.                     break;
  261.  
  262.  
  263.                 /*
  264.                  * Invalid ioctl function code
  265.                  */
  266.                 default:
  267.                     status |= STERR + ERROR_I24_BAD_COMMAND;
  268.                     break;
  269.             } /* end switch */
  270.         } else {
  271.             /*
  272.              * invalid category
  273.              */
  274.             status |= STERR + ERROR_I24_BAD_COMMAND;
  275.         }
  276.     } else {
  277.         /*
  278.          * error while thunking reqpkt
  279.          */
  280.         status |= STERR + ERROR_I24_INVALID_PARAMETER;
  281.     }
  282.     return (status | STDON);
  283. }
  284.