开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > TCP/IP协议栈 > 查看源码
dos.c
资源名称：export.zip　[点击查看]
上传用户：hepax88
上传日期：2007-01-03
资源大小：1101k
文件大小：8k
源码类别：

TCP/IP协议栈

开发平台：

Visual C++

dos.c：源码内容
  1. /* This file provides direct calls to the MS-DOS file system primitives
  2.  * _creat(), _open(), _close(), _read(), _write(), _lseek() and dup()
  3.  *
  4.  * These are necessary to allow more open file handles than permitted
  5.  * by the compiled-in table sizes in the Borland C library
  6.  */
  8. #include <io.h>
  9. #include <dos.h>
  10. #include <errno.h>
  11. #include <fcntl.h>
  12. #include "stdio.h"
  13. #include "global.h"
  15. /* Table for mapping MS-DOS errors to UNIX errno values */
  16. static int _ioerr[] = {
  17.     0, /*  0 - OK      */
  18.     EINVAL, /*  1 - e_badFunction      */
  19.     ENOENT, /*  2 - e_fileNotFound      */
  20.     ENOENT, /*  3 - e_pathNotFound      */
  21.     EMFILE, /*  4 - e_tooManyOpen      */
  22.     EACCES, /*  5 - e_accessDenied      */
  23.     EBADF, /*  6 - e_badHandle      */
  24.     ENOMEM, /*  7 - e_mcbDestroyed      */
  25.     ENOMEM, /*  8 - e_outOfMemory      */
  26.     ENOMEM, /*  9 - e_badBlock      */
  27.     E2BIG, /* 10  e_badEnviron     */
  28.     ENOEXEC, /* 11  e_badFormat     */
  29.     EACCES, /* 12  e_badAccess     */
  30.     EINVAL, /* 13  e_badData     */
  31.     EFAULT, /* 14  reserved     */
  32.     EXDEV, /* 15  e_badDrive     */
  33.     EACCES, /* 16  e_isCurrentDir     */
  34.     ENOTSAM, /* 17  e_notSameDevice     */
  35.     ENOENT, /* 18  e_noMoreFiles     */
  36.     EROFS, /* 19  e_readOnly     */
  37.     ENXIO, /* 20  e_unknownUnit     */
  38.     EBUSY, /* 21  e_notReady     */
  39.     EIO, /* 22  e_unknownCommand     */
  40.     EIO, /* 23  e_dataError     */
  41.     EIO, /* 24  e_badRequestLength   */
  42.     EIO, /* 25  e_seekError     */
  43.     EIO, /* 26  e_unknownMedia     */
  44.     ENXIO, /* 27  e_sectorNotFound     */
  45.     EBUSY, /* 28  e_outOfPaper     */
  46.     EIO, /* 29  e_writeFault     */
  47.     EIO, /* 30  e_readFault     */
  48.     EIO, /* 31  e_generalFault     */
  49.     EACCES, /* 32  e_sharing     */
  50.     EACCES, /* 33  e_lock     */
  51.     ENXIO, /* 34  e_diskChange     */
  52.     ENFILE, /* 35  e_FCBunavailable     */
  53.     ENFILE, /* 36  e_sharingOverflow    */
  54.     EFAULT, EFAULT,
  55.     EFAULT, EFAULT,
  56.     EFAULT, EFAULT,
  57.     EFAULT, EFAULT,
  58.     EFAULT, EFAULT,
  59.     EFAULT, EFAULT,
  60.     EFAULT, /* 37-49  reserved     */
  61.     ENODEV, /* 50  e_networkUnsupported */
  62.     EBUSY, /* 51  e_notListening     */
  63.     EEXIST, /* 52  e_dupNameOnNet     */
  64.     ENOENT, /* 53  e_nameNotOnNet     */
  65.     EBUSY, /* 54  e_netBusy     */
  66.     ENODEV, /* 55  e_netDeviceGone     */
  67.     EAGAIN, /* 56  e_netCommandLimit    */
  68.     EIO, /* 57  e_netHardError     */
  69.     EIO, /* 58  e_wrongNetResponse   */
  70.     EIO, /* 59  e_netError     */
  71.     EINVAL, /* 60  e_remoteIncompatible */
  72.     EFBIG, /* 61  e_printQueueFull     */
  73.     ENOSPC, /* 62  e_printFileSpace     */
  74.     ENOENT, /* 63  e_printFileDeleted   */
  75.     ENOENT, /* 64  e_netNameDeleted     */
  76.     EACCES, /* 65  e_netAccessDenied    */
  77.     ENODEV, /* 66  e_netDeviceWrong     */
  78.     ENOENT, /* 67  e_netNameNotFound    */
  79.     ENFILE, /* 68  e_netNameLimit     */
  80.     EIO, /* 69  e_netBIOSlimit     */
  81.     EAGAIN, /* 70  e_paused     */
  82.     EINVAL, /* 71  e_netRequestRefused  */
  83.     EAGAIN, /* 72  e_redirectionPaused  */
  84.     EFAULT, EFAULT,
  85.     EFAULT, EFAULT,
  86.     EFAULT, EFAULT,
  87.     EFAULT, /* 73- 79  reserved     */
  88.     EEXIST, /* 80  e_fileExists     */
  89.     EFAULT, /* 81  reserved     */
  90.     ENOSPC, /* 82  e_cannotMake     */
  91.     EIO, /* 83  e_failInt24     */
  92.     ENFILE, /* 84  e_redirectionLimit   */
  93.     EEXIST, /* 85  e_dupRedirection     */
  94.     EPERM, /* 86  e_password     */
  95.     EINVAL, /* 87  e_parameter     */
  96.     EIO, /* 88  e_netDevice     */
  97. };
  98. #define NERROR 89
  100. /* Reference count table for open file descriptors */
  101. unsigned *Refcnt;
  103. int
  104. _creat(file,mode)
  105. const char *file; /* File name to create */
  106. int mode; /* Ignored */
  107. {
  108. union REGS regs;
  109. struct SREGS segregs;
  110. int fd;
  112. segregs.ds = FP_SEG(file);
  113. regs.x.dx = FP_OFF(file);
  114. regs.x.cx = 0; /* Normal attributes */
  115. regs.h.ah = 0x3c;
  116. intdosx(&regs,&regs,&segregs);
  117. fd = regs.x.ax;
  118. if(regs.x.cflag){
  119. if(fd < NERROR)
  120. errno = _ioerr[fd];
  121. return -1;
  122. }
  123. Refcnt[fd] = 1;
  124. return fd; /* Return handle */
  125. }
  126. int
  127. _open(file,mode)
  128. const char *file;
  129. int mode;
  130. {
  131. union REGS regs;
  132. struct SREGS segregs;
  133. int dosmode,fd;
  135. if(mode & O_TRUNC){
  136. remove(file);
  137. mode |= O_CREAT;
  138. }
  139. /* Translate unix to MS-DOS open modes */
  140. switch(mode & (O_RDONLY|O_WRONLY|O_RDWR)){
  141. case O_RDONLY:
  142. dosmode = 0;
  143. break;
  144. case O_WRONLY:
  145. dosmode = 1;
  146. break;
  147. case O_RDWR:
  148. dosmode = 2;
  149. break;
  150. default:
  151. errno = EINVAL;
  152. return -1;
  153. }
  154. if(mode & O_EXCL)
  155. dosmode |= 0x10;
  157. segregs.ds = FP_SEG(file);
  158. regs.x.dx = FP_OFF(file);
  159. regs.h.al = dosmode;
  160. regs.h.ah = 0x3d;
  161. intdosx(&regs,&regs,&segregs);
  162. fd = regs.x.ax;
  163. if(regs.x.cflag){
  164. if(fd < NERROR){
  165. errno = _ioerr[fd];
  166. if(errno == ENOENT && (mode & O_CREAT))
  167. return _creat(file,0);
  168. }
  169. return -1;
  170. }
  171. Refcnt[fd] = 1;
  172. return fd; /* Return handle */
  173. }
  174. /* Dup a file descriptor. Rather than allocating a new descriptor,
  175.  * as in UNIX or MS-DOS, we maintain a reference count table so we
  176.  * can return the same descriptor that is passed. This saves precious
  177.  * file descriptor space.
  178.  */
  179. int
  180. dup(fd)
  181. int fd;
  182. {
  183. if(fd < 0 || _fd_type(fd) != _FL_FILE){
  184. errno = EINVAL; /* Valid only on files */
  185. return -1;
  186. }
  187. fd = _fd_seq(fd);
  188. if(fd >= Nfiles || Refcnt[fd] == 0){
  189. errno = EINVAL;
  190. return -1;
  191. }
  192. Refcnt[fd]++;
  193. return fd;
  194. }
  196. int
  197. _close(fd)
  198. int fd;
  199. {
  200. union REGS regs;
  202. if(fd < 0 || _fd_type(fd) != _FL_FILE){
  203. errno = EINVAL; /* Valid only on files */
  204. return -1;
  205. }
  206. fd = _fd_seq(fd);
  207. if(fd >= Nfiles || Refcnt[fd] == 0){
  208. errno = EINVAL;
  209. return -1;
  210. }
  211. if(--Refcnt[fd] != 0)
  212. return 0; /* Somebody else is still using it */
  213. regs.x.bx = fd;
  214. regs.h.ah = 0x3e;
  215. intdos(&regs,&regs);
  216. if(regs.x.cflag){
  217. if(regs.x.ax < NERROR)
  218. errno = _ioerr[regs.x.ax];
  219. return -1;
  220. }
  221. return 0;
  222. }
  223. int
  224. _read(fd,buf,cnt)
  225. int fd;
  226. void *buf;
  227. unsigned cnt;
  228. {
  229. union REGS regs;
  230. struct SREGS segregs;
  232. if(fd < 0 || _fd_type(fd) != _FL_FILE){
  233. errno = EINVAL; /* Valid only on files */
  234. return -1;
  235. }
  236. fd = _fd_seq(fd);
  237. if(fd >= Nfiles || Refcnt[fd] == 0){
  238. errno = EINVAL;
  239. return -1;
  240. }
  241. regs.x.bx = fd;
  242. regs.x.cx = cnt;
  243. segregs.ds = FP_SEG(buf);
  244. regs.x.dx = FP_OFF(buf);
  245. regs.h.ah = 0x3f;
  246. intdosx(&regs,&regs,&segregs);
  247. if(regs.x.cflag){
  248. if(regs.x.ax < NERROR)
  249. errno = _ioerr[regs.x.ax];
  250. return -1;
  251. }
  252. return regs.x.ax; /* Return count */
  253. }
  254. int
  255. _write(fd,buf,cnt)
  256. int fd;
  257. const void *buf;
  258. unsigned cnt;
  259. {
  260. union REGS regs;
  261. struct SREGS segregs;
  263. if(fd < 0 || _fd_type(fd) != _FL_FILE){
  264. errno = EINVAL; /* Valid only on files */
  265. return -1;
  266. }
  267. fd = _fd_seq(fd);
  268. if(fd >= Nfiles || Refcnt[fd] == 0){
  269. errno = EINVAL;
  270. return -1;
  271. }
  272. regs.x.bx = fd;
  273. regs.x.cx = cnt;
  274. segregs.ds = FP_SEG(buf);
  275. regs.x.dx = FP_OFF(buf);
  276. regs.h.ah = 0x40;
  277. intdosx(&regs,&regs,&segregs);
  278. if(regs.x.cflag){
  279. if(regs.x.ax < NERROR)
  280. errno = _ioerr[regs.x.ax];
  281. return -1;
  282. }
  283. cnt = regs.x.ax; /* Return count */
  285. /* Not really necessary when share.exe is loaded, and it really slows down
  286.  * machines without disk write caches
  287.  */
  288. #ifdef notdef
  289. /* Call the "commit file" command to flush it out (will fail for
  290.  * MS-DOS before 3.3)
  291.  */
  292. regs.x.bx = fd;
  293. regs.h.ah = 0x68;
  294. intdos(&regs,&regs);
  295. #endif
  296. return cnt;
  297. }
  298. long
  299. _lseek(fd,offset,whence)
  300. int fd;
  301. long offset;
  302. int whence;
  303. {
  304. union REGS regs;
  306. if(fd < 0 || _fd_type(fd) != _FL_FILE){
  307. errno = EINVAL; /* Valid only on files */
  308. return -1;
  309. }
  310. fd = _fd_seq(fd);
  311. if(fd >= Nfiles || Refcnt[fd] == 0){
  312. errno = EINVAL;
  313. return -1;
  314. }
  315. regs.x.bx = fd;
  316. regs.x.cx = offset >> 16;
  317. regs.x.dx = offset;
  318. regs.h.al = whence;
  319. regs.h.ah = 0x42;
  320. intdos(&regs,&regs);
  321. if(regs.x.cflag){
  322. if(regs.x.ax < NERROR)
  323. errno = _ioerr[regs.x.ax];
  324. return -1;
  325. }
  326. /* Return new offset */
  327. return ((long)regs.x.dx << 16) | regs.x.ax;
  328. }