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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
NMPSDMP.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：20k
源码类别：

Windows编程

开发平台：

Visual C++

NMPSDMP.C：源码内容
  1. // NMPSDMP.C
  2. //
  3. // DBLIB program for using named pipe dump devices for backup and restore data
  4. // from SQL Server 95.This program is an example and shows the usage of named pipe
  5. // dump devices on the client side.
  6. //
  7. //
  8. // The program needs the following arguments (it asks from the user interactively) :
  9. // Operation : DUMP/LOAD
  10. // Servername : Name of the server to dump from/load into
  11. // Databasename: Name of the database to be dumped/loaded
  12. // Stripenum : How many pipes are to be used for dump/load
  13. // Dumpname : Prefix of the files to write/read the dumped/load data (DMP postfix)
  15. #define DBNTWIN32
  16. #include <windows.h>
  17. #include <stdlib.h>
  18. #include <stdio.h>
  19. #include <process.h>
  20. #include <sqlfront.h>
  21. #include <sqldb.h>
  23. // definitions
  24. #define MAX_DEVICES 32 // maximum number of stripe devices
  25. #define PIPE_WAIT_TIME 500 // wait time in milliseconds
  26. #define DBPAGESIZE 2048 // size of physical page dumped
  28. // status values for dump/load threads
  29. #define STAT_SUCCESS 0x0 // default status
  30. #define STAT_ERROR 0x1    // error in the current thread
  31. #define STAT_ENDTHREAD 0x2 // the current thread has terminated
  33. // opcode values
  34. #define DUMP_MODE 0x1 // dump mode of operation
  35. #define LOAD_MODE 0x2 // load mode of operation
  37. // this structure is maintained on a global basis among all threads that
  38. // are doing reads/writes from pipe
  39. typedef struct ginfo
  40. {
  41. char  servername[30]; // server name
  42. char  dbname[30]; // database name
  43. char  dumpname[80]; // dump file prefix
  44. char password[30]; // dblogin password of SA
  45. long status; // global status flag for error recovery
  46. short opcode; // operation code
  47. short stripenum; // number of pipe devices to be used
  48. } GINFO;
  50. // this structure contains pipe specific info to be run by different threads
  51. // that read/write data during the stripe dump/load
  52. typedef struct pipeinfo
  53. {
  54. char pipename[80]; // Physical name of pipe used for client
  55. char spipename[80]; // Physical name of pipe sent to SQL Server
  56. char dumpname[80]; // Physical name of the dump file
  57. short slot; // which device slot
  58. GINFO *curinfo; // pointer to global info buffer
  59. long status; // thread local status
  60. } PIPEINFO;
  62. // Macros
  63. # define NEWARG(i)    (*(argv[i]) == '-' || *(argv[i]) == '/')
  64. # define BUFALIGN(a)    ( (BYTE *) ( ((long)a + 64) & 0xffffffc0) )
  67. // function prototypes
  68. void parse_parms(int argc, char *argv[], GINFO *curinfo);
  69. void argvalue(int i, int argc, char* argv[], char* out);
  70. int set_up_pipes(GINFO *curinfo, PIPEINFO **pipes);
  71. void close_up_pipes(GINFO *curinfo, PIPEINFO **pipes);
  72. void dump_proc(PIPEINFO *curpipe);
  73. void load_proc(PIPEINFO *curpipe);
  74. INT msg_handler(PDBPROCESS,DBINT,INT,INT,LPCSTR,LPCSTR,LPCSTR,DBUSMALLINT);
  75. INT err_handler(PDBPROCESS,INT,INT,INT,LPCSTR,LPCSTR);
  77. // start of the progam
  78. main(int argc, char *argv[])
  79. {
  81. RETCODE retcode; // DBLIB return code
  82. LOGINREC  *loginrec = NULL; // DBLIB LOGINREC pointer
  83. DBPROCESS  *dbproc = NULL; // DBLIB DBPROC pointer
  84. GINFO info; // to store global info & status
  85. PIPEINFO *pipes[MAX_DEVICES]; // array of PIPEINFO pointers
  86. char cmd[1024]; // SQL command buffer
  88.     // scratch variables
  89.    char scratch[80];
  90. int i;
  92.    // Initialize
  93. for (i=0; i<MAX_DEVICES; i++)
  94. pipes[i] = NULL;
  96. info.servername[0] = 0;
  97. info.dbname[0] = 0;
  98. info.dumpname[0] = 0;
  99. info.password[0] = 0;
  100. info.stripenum = 1;
  101. info.opcode = DUMP_MODE;
  102. info.status = STAT_SUCCESS;
  104. // read the user input
  105. parse_parms(argc, argv, &info);
  107. // Install the DBLIB handlers
  108. dberrhandle(err_handler);
  109. dbmsghandle(msg_handler);
  111. printf("Logging on to server...n");
  113. loginrec = dblogin();
  114. DBSETLUSER(loginrec, "sa");
  115. DBSETLPWD(loginrec,"");
  117. if ((dbproc = dbopen(loginrec, info.servername)) == (DBPROCESS *)NULL)
  118. {
  119.   printf("dbopen() failed");
  120.   info.status |= STAT_ERROR;
  121.   goto clean_up;
  122. };
  124. // Set up the thread(s) for reading/writing the pipe device
  125. if (!set_up_pipes(&info, pipes))
  126. {
  127. info.status |= STAT_ERROR;
  128. goto clean_up;
  129. }
  131. // prepare the command now
  132. if (info.opcode == DUMP_MODE)
  133. strcpy(cmd, "dump database ");
  134. else
  135. strcpy(cmd, "load database ");
  136. strcat(cmd, info.dbname);
  137. if (info.opcode == DUMP_MODE)
  138. strcat(cmd, " to ");
  139. else
  140. strcat(cmd, " from ");
  141. for (i=0; i < info.stripenum; i++)
  142. {
  143. sprintf(scratch, "pipe = '%s'", &pipes[i]->spipename);
  144. strcat(cmd, scratch);
  145. if ((i+1) < info.stripenum)
  146. strcat(cmd, ", ");
  147. }
  148. printf("Command : <%s>n", cmd);
  150. // this thread will be blocked till the dump/load command is not
  151. // completed; for changing the behavior to non blocking, use
  152. // dbsqlsend(), dbdataready() and dbsqlok() instead of dbsqlexec()
  153. retcode = dbcmd(dbproc, cmd);
  154.     retcode = dbsqlexec(dbproc);
  156.     if (retcode != SUCCEED)
  157. {
  158. printf("dbsqlexec failedn");
  159. info.status |= STAT_ERROR;
  160. goto clean_up;
  161. }
  163.     // discard results ; we do not need it
  164.     while (dbresults(dbproc) == SUCCEED)
  165.      while (dbnextrow(dbproc) != NO_MORE_ROWS)
  166. ;
  168. // We are done with all the work ; clean up the resources and exit
  169. // strictly speaking, cleanup is not necessary for this since we
  170. // will exit the program (but for implementing this as a procedures
  171. // would involve cleanup)
  172. clean_up:
  174. if (dbproc)
  175.     dbclose(dbproc);
  176. if (loginrec)
  177. dbfreelogin(loginrec);
  179. close_up_pipes(&info, pipes);
  180. exit(1);
  181.     return(0);
  182. }
  184. // procedure to get all the parameters
  185. void  parse_parms(int argc, char *argv[], GINFO *curinfo)
  186. {
  187. int     i;
  188. char    argval[30];
  190. for (i = 0 ; i < argc; i++)
  191. {
  192. if (NEWARG(i))
  193. {
  194. switch(*(argv[i] + 1))
  195. {
  196. case 'S' : // Servername
  197. argvalue(i,argc,argv,curinfo->servername);
  198. break;
  200. case 'D' : // Databasename
  201. argvalue(i,argc,argv,curinfo->dbname);
  202. break;
  204. case 'P' : // SA password
  205. argvalue(i,argc,argv,curinfo->password);
  206. break;
  208. case 'N' : // Stripe Number
  209. argvalue(i,argc,argv,argval);
  210. if ((curinfo->stripenum = (short)atoi(argval)) < 1)
  211. {
  212. printf("Invalid value %d for stripe device. Setting to 1n");
  213. curinfo->stripenum = 1;
  214. }
  215. else if (curinfo->stripenum > MAX_DEVICES)
  216. {
  217. printf("Invalid value %d for stripe device. Setting to %dn",
  218. MAX_DEVICES);
  219. curinfo->stripenum = MAX_DEVICES;
  220. }
  221. break;
  223. case 'F' : // Dump file prefix
  224. argvalue(i,argc,argv,curinfo->dumpname);
  225. break;
  227. case 'O' : // Mode of operation
  228. argvalue(i,argc,argv,argval);
  229. if ( (!strcmp(argval, "DUMP")) || (!strcmp(argval, "dump")) )
  230. curinfo->opcode = DUMP_MODE;
  231. else if ( (!strcmp(argval, "LOAD")) || (!strcmp(argval, "load")) )
  232. curinfo->opcode = LOAD_MODE;
  233. else
  234. {
  235. printf("Invalid mode %s specifiedn", argval);
  236. exit(1);
  237. }
  238. break;
  240. case '?' : // Help message
  241. printf("NMPSDMP -Sservername -Ppassword -O{dump | load} -Ddatabasename -Nstripenumber -Fdumpprefixn");
  242. exit(1);
  243. break;
  245. default:
  246. printf("Invalid parameter option : %sn", *(argv[i] + 1) );
  247. printf("NMPSDMP -Sservername -Ppassword -O{dump | load} -Ddatabasename -Nstripenumber -Fdumpprefixn");
  248. exit(1);
  249. }
  250. }
  251. }
  252. return;
  253. }
  255. // argument reading routine for parse_parms()
  256. void argvalue(
  257.     int   i,                           // parameter number
  258.     int   argc,                        // #args
  259.     char* argv[],                      // arglist
  260.     char* out                          // receives parm 'i'
  261. ){
  262. if( *(argv[i]+2) )
  263. strcpy(out, argv[i]+2);
  264. else
  265. {
  266. if( i+1<argc && !( NEWARG(i+1) ) )
  267.             strcpy(out, argv[i+1]);
  268. }
  269. }
  271. // procedure to setup all the threads for reading pipes
  272. //
  273. // return : 1 if success
  274. // 0 otherwise
  275. int set_up_pipes(GINFO *curinfo, PIPEINFO **pipes)
  276. {
  278. int i;
  279. PIPEINFO *curpipe;
  280. char pipebuf[30];
  282. // for every device
  283. for (i=0; i < curinfo->stripenum; i++)
  284. {
  285. // allocate for the current pipe
  286. if ((curpipe = malloc(sizeof(PIPEINFO))) == NULL)
  287. return 0;
  288. curpipe->slot = i;
  289. curpipe->curinfo = curinfo;
  290. curpipe->status = STAT_SUCCESS;
  292. // prepare the pipe name
  293. strcpy(curpipe->pipename, "\\");
  294. strcpy(curpipe->spipename, "\\");
  295. if (curinfo->servername[0])
  296. strcat(curpipe->pipename, curinfo->servername);
  297. else
  298. strcat(curpipe->pipename, ".");
  299. strcat(curpipe->spipename, ".");
  300. strcat(curpipe->pipename, "\pipe\");
  301. strcat(curpipe->spipename, "\pipe\");
  302. sprintf(pipebuf, "sqldmpld%d", i);
  303. strcat(curpipe->pipename, pipebuf);
  304. strcat(curpipe->spipename, pipebuf);
  306. // prepare the dump file name
  307. sprintf(curpipe->dumpname, "%s%d.dmp", curinfo->dumpname, i);
  309. // now start the thread for this device
  310. pipes[i] = curpipe;
  311. if (curinfo->opcode == DUMP_MODE)
  312. {
  313. if (!(_beginthread(dump_proc, 0, (LPVOID)curpipe)))
  314. {
  315. printf("beginthread failed for slot %dn", i);
  316. return 0;
  317. }
  318. }
  319. else
  320. {
  321. if (!(_beginthread(load_proc, 0, (LPVOID)curpipe)))
  322. {
  323. printf("beginthread failed for slot %dn", i);
  324. return 0;
  325. }
  326. }
  327. }
  329. // started all the threads
  330. return 1;
  331. }
  333. // procedure to close all the threads for reading/writing pipes
  334. //
  335. // return : nothing
  336. //
  337. void close_up_pipes(GINFO *curinfo, PIPEINFO **pipes)
  338. {
  339. int i;
  340. PIPEINFO *curpipe;
  342. // check if we need to clean up
  343. if (!curinfo->stripenum)
  344. return;
  346. // for every open device
  347. for (i=0; i < curinfo->stripenum; i++)
  348. {
  349. if (!(curpipe = pipes[i]))
  350. continue;
  352. // wait for the thread to close itself
  353. while (!(curpipe->status & STAT_ENDTHREAD))
  354. SleepEx(10, TRUE);
  356. // free the allocated memory
  357. free(curpipe);
  358. }
  359. }
  361. // DUMP_PROC
  362. //  This procedure does the opening and reading of dumped data sent
  363. // by the SQL Server. Each thread invoked with this routine services
  364. // one named pipe (instance) connection; for simplicity we are creating
  365. // separate named pipes for each stripe number.
  366. //
  367. // For dump process, the thread opens the pipe created by SQL Server
  368. //  and connects to it. Then keeps reading data and writing it
  369. // out to the dumpfile till the SQL Server is done.
  371. void dump_proc(PIPEINFO *curpipe)
  372. {
  373. GINFO *curinfo = curpipe->curinfo;
  374. HANDLE hpipe = NULL;
  375. HANDLE hfile = NULL;
  376. BYTE *buf_start = NULL;
  377. BYTE *buf_ptr;
  378. DWORD bufsize, cbread, cbwritten, mode;
  379. DWORD errcode = 0;
  380. DWORD offl, offh;
  382. // Open the pipe
  383. while (1)
  384. {
  386. // check the global flag
  387. if (curinfo->status & STAT_ERROR)
  388. goto dump_proc_cleanup;
  390. hpipe = CreateFile(curpipe->pipename,
  391. GENERIC_READ | GENERIC_WRITE, 0, NULL,
  392. OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH, NULL);
  394. // break if handle is valid
  395. if (hpipe != INVALID_HANDLE_VALUE)
  396. break;
  398. // check the pipe state
  399. errcode = GetLastError();
  400. if (errcode == ERROR_FILE_NOT_FOUND)
  401. {
  402. // SQL Server has not yet created the pipe; wait
  403. SleepEx(PIPE_WAIT_TIME, TRUE);
  404. continue;
  405. }
  406. else if (errcode != ERROR_PIPE_BUSY)
  407. {
  408. printf("Error in %s : %dn", "CreateFile", errcode);
  409. curpipe->status |= STAT_ERROR;
  410. goto dump_proc_cleanup;
  411. }
  413. // Wait for sometime if pipe is busy
  414. if (!WaitNamedPipe(curpipe->pipename, PIPE_WAIT_TIME))
  415. {
  416. printf("Error in %s : %dn", "WaitNamedPipe", GetLastError());
  417. curpipe->status |= STAT_ERROR;
  418. goto dump_proc_cleanup;
  419. }
  420. }
  422. printf("dump thread : %d : connected to servern", curpipe->slot);
  424. // get the buffer size
  425. if ((!GetNamedPipeInfo(hpipe, NULL, NULL, &bufsize, NULL)) || (bufsize == 0))
  426. {
  427. printf("Error in %s : %dn", "GetNamedPipeInfo", GetLastError());
  428. curpipe->status |= STAT_ERROR;
  429. goto dump_proc_cleanup;
  430. }
  432. // Align the buffer size to database pagesize if necessary
  433. if (bufsize % DBPAGESIZE)
  434. bufsize = ((bufsize / DBPAGESIZE) - 1) * DBPAGESIZE;
  435. //printf("dump thread : %d : buffer size %d n", curpipe->slot, bufsize);
  437. // allocate the buffer for reading incoming data and align it
  438. if ((buf_start = malloc(bufsize + 64)) == NULL)
  439. {
  440. printf("malloc failedn");
  441. curpipe->status |= STAT_ERROR;
  442. goto dump_proc_cleanup;
  443. }
  444. buf_ptr = BUFALIGN(buf_start);
  446. // Set the pipe mode to message read mode 
  447. mode = PIPE_READMODE_MESSAGE;
  448. if (!SetNamedPipeHandleState(hpipe, &mode, NULL, NULL))
  449. {
  450. printf("Error in %s : %dn", "SetNamedPipeHandleState", GetLastError());
  451. curpipe->status |= STAT_ERROR;
  452. goto dump_proc_cleanup;
  453. }
  455. // open the dump file ; if it exists then overwrite it
  456. // otherwise open a new file
  457. hfile = CreateFile(curpipe->dumpname,
  458.             GENERIC_READ | GENERIC_WRITE, 0, NULL,
  459.             CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
  460. if (hfile == INVALID_HANDLE_VALUE)
  461. {
  462. printf("Error in %s : %dn", "CreateFile", GetLastError());
  463. curpipe->status |= STAT_ERROR;
  464. goto dump_proc_cleanup;
  465. }
  467. // set the file pointer to start of file
  468. offh = 0;
  469. if ((offl = SetFilePointer(hfile, 0, &offh, FILE_BEGIN)) == -1)
  470. {
  471. printf("Error in %s : %dn", "SetFilePointer", GetLastError());
  472. curpipe->status |= STAT_ERROR;
  473. goto dump_proc_cleanup;
  474. }
  476. // now we are all set to read from the pipe; keep reading till the pipe is
  477. // closed.
  478. while (1)
  479. {
  480. // check the global flag
  481. if (curinfo->status & STAT_ERROR)
  482. goto dump_proc_cleanup;
  484. if (!ReadFile(hpipe, buf_ptr, bufsize, &cbread, NULL))
  485. {
  486. // Are we done reading
  487. if ((errcode = GetLastError()) == ERROR_BROKEN_PIPE)
  488. break;
  489. if (errcode != ERROR_MORE_DATA)
  490. {
  491. printf("Error in %s : %dn", "ReadFile", errcode);
  492. curpipe->status |= STAT_ERROR;
  493. goto dump_proc_cleanup;
  494. }
  495. }
  496. //printf("dump thread : %d : read %d bytesn", curpipe->slot, cbread);
  497. if (!WriteFile(hfile, buf_ptr, cbread, &cbwritten, NULL))
  498. {
  499. printf("Error in %s : %dn", "WriteFile", GetLastError());
  500. curpipe->status |= STAT_ERROR;
  501. goto dump_proc_cleanup;
  502. }
  503. }
  505. dump_proc_cleanup:
  507. // release the resources
  508. if (buf_start)
  509. free(buf_start);
  510. if (hfile)
  511. {
  512. FlushFileBuffers(hfile);
  513. CloseHandle(hfile);
  514. }
  515. if (hpipe)
  516. CloseHandle(hpipe);
  518. // set the status flags
  519. curpipe->status |= STAT_ENDTHREAD;
  520. if (curpipe->status & STAT_ERROR)
  521. curinfo->status |= STAT_ERROR;
  523. return;
  524. }
  526. // LOAD_PROC
  527. //  This procedure does the opening and writing of dumped data sent
  528. // to the SQL Server. Each thread invoked with this routine services
  529. // one named pipe (instance) connection; we are create
  530. // separate named pipes for each stripe number.
  531. //
  532. // For load process, the thread opens the pipe created by SQL Server
  533. //  and connects to it. Then keeps reading data from the dumpfile till end
  534. //  and writes to the pipe; Finally closes the pipe when done.
  536. void load_proc(PIPEINFO *curpipe)
  537. {
  538. GINFO *curinfo = curpipe->curinfo;
  539. HANDLE hpipe = NULL;
  540. HANDLE hfile = NULL;
  541. BYTE *buf_start = NULL;
  542. BYTE *buf_ptr;
  543. DWORD bufsize, cbread, cbwritten, mode;
  544. DWORD errcode = 0;
  545. DWORD offl, offh;
  547. // Open the pipe
  548. while (1)
  549. {
  551. // check the global flag
  552. if (curinfo->status & STAT_ERROR)
  553. goto load_proc_cleanup;
  555. hpipe = CreateFile(curpipe->pipename,
  556. GENERIC_READ | GENERIC_WRITE, 0, NULL,
  557. OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH, NULL);
  559. // break if handle is valid
  560. if (hpipe != INVALID_HANDLE_VALUE)
  561. break;
  563. // check the pipe state
  564. errcode = GetLastError();
  565. if (errcode == ERROR_FILE_NOT_FOUND)
  566. {
  567. // SQL Server has not yet created the pipe; wait
  568. SleepEx(PIPE_WAIT_TIME, TRUE);
  569. continue;
  570. }
  571. else if (errcode != ERROR_PIPE_BUSY)
  572. {
  573. printf("Error in %s : %dn", "CreateFile", errcode);
  574. curpipe->status |= STAT_ERROR;
  575. goto load_proc_cleanup;
  576. }
  578. // Wait for sometime if pipe is busy
  579. if (!WaitNamedPipe(curpipe->pipename, PIPE_WAIT_TIME))
  580. {
  581. printf("Error in %s : %dn", "WaitNamedPipe", GetLastError());
  582. curpipe->status |= STAT_ERROR;
  583. goto load_proc_cleanup;
  584. }
  585. }
  587. printf("load thread : %d : connected to servern", curpipe->slot);
  589. // get the buffer size
  590. if ((!GetNamedPipeInfo(hpipe, NULL, NULL, &bufsize, NULL)) || (bufsize == 0))
  591. {
  592. printf("Error in %s : %dn", "GetNamedPipeInfo", GetLastError());
  593. curpipe->status |= STAT_ERROR;
  594. goto load_proc_cleanup;
  595. }
  597. // Align the buffer size to database pagesize if necessary
  598. if (bufsize % DBPAGESIZE)
  599. bufsize = ((bufsize / DBPAGESIZE) - 1) * DBPAGESIZE;
  600. //printf("load thread : %d : buffer size %d n", curpipe->slot, bufsize);
  602. // allocate the buffer for reading incoming data and align it
  603. if ((buf_start = malloc(bufsize + 64)) == NULL)
  604. {
  605. printf("malloc failedn");
  606. curpipe->status |= STAT_ERROR;
  607. goto load_proc_cleanup;
  608. }
  609. buf_ptr = BUFALIGN(buf_start);
  611. // Set the pipe mode to message read mode 
  612. mode = PIPE_READMODE_MESSAGE;
  613. if (!SetNamedPipeHandleState(hpipe, &mode, NULL, NULL))
  614. {
  615. printf("Error in %s : %dn", "SetNamedPipeHandleState", GetLastError());
  616. curpipe->status |= STAT_ERROR;
  617. goto load_proc_cleanup;
  618. }
  620. // open the dump file ; it should exist
  621. hfile = CreateFile(curpipe->dumpname,
  622.             GENERIC_READ | GENERIC_WRITE, 0, NULL,
  623.             OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
  624. if (hfile == INVALID_HANDLE_VALUE)
  625. {
  626. printf("Error in %s : %dn", "CreateFile", GetLastError());
  627. curpipe->status |= STAT_ERROR;
  628. goto load_proc_cleanup;
  629. }
  631. // set the file pointer to start of file
  632. offh = 0;
  633. if ((offl = SetFilePointer(hfile, 0, &offh, FILE_BEGIN)) == -1)
  634. {
  635. printf("Error in %s : %dn", "SetFilePointer", GetLastError());
  636. curpipe->status |= STAT_ERROR;
  637. goto load_proc_cleanup;
  638. }
  640. //
  641. // Read the first page and write it to the pipe
  642. //
  643. if ((!ReadFile(hfile, buf_ptr, DBPAGESIZE, &cbread, NULL)) || 
  644. (cbread != DBPAGESIZE))
  645. {
  646. printf("Error in %s : %dn", "ReadFile", GetLastError());
  647. curpipe->status |= STAT_ERROR;
  648. goto load_proc_cleanup;
  649. }
  650. if (!WriteFile(hpipe, buf_ptr, DBPAGESIZE, &cbwritten, NULL))
  651. {
  652. printf("Error in %s : %dn", "WriteFile", errcode);
  653. curpipe->status |= STAT_ERROR;
  654. goto load_proc_cleanup;
  655. }
  656. //printf("load thread : %d : wrote %d bytesn", curpipe->slot, cbwritten);
  658. // now we are all set to read from the dumpfile; keep reading till we reach
  659. // the end of dumpfile
  660. while (1)
  661. {
  662. // check the global flag
  663. if (curinfo->status & STAT_ERROR)
  664. goto load_proc_cleanup;
  666. // read from the dump file
  667. if (!ReadFile(hfile, buf_ptr, bufsize, &cbread, NULL))
  668. {
  669. // check if we are done reading
  670. if ((errcode = GetLastError()) == ERROR_HANDLE_EOF)
  671. break;
  673. printf("Error in %s : %dn", "ReadFile", GetLastError());
  674. curpipe->status |= STAT_ERROR;
  675. goto load_proc_cleanup;
  676. }
  678. // Done reading the dump file
  679. if (cbread == 0)
  680. break;
  682. // write to the pipe
  683. if (!WriteFile(hpipe, buf_ptr, cbread, &cbwritten, NULL))
  684. {
  685. printf("Error in %s : %dn", "WriteFile", GetLastError());
  686. curpipe->status |= STAT_ERROR;
  687. goto load_proc_cleanup;
  688. }
  689. //printf("load thread : %d : wrote %d bytesn", curpipe->slot, cbwritten);
  690. }
  692. load_proc_cleanup:
  694. // release the resources
  695. if (buf_start)
  696. free(buf_start);
  697. if (hfile)
  698. CloseHandle(hfile);
  699. if (hpipe)
  700. {
  701. FlushFileBuffers(hpipe);
  702. CloseHandle(hpipe);
  703. }
  705. // set the status flags
  706. curpipe->status |= STAT_ENDTHREAD;
  707. if (curpipe->status & STAT_ERROR)
  708. curinfo->status |= STAT_ERROR;
  710. return;
  711. }
  714. INT msg_handler(dbproc,msgno,msgstate, severity, msgtext,server,proc,line)
  715. PDBPROCESS  dbproc;
  716. DBINT  msgno;
  717. INT  msgstate;
  718. INT  severity;
  719. LPCSTR msgtext;
  720. LPCSTR server;
  721. LPCSTR proc;
  722. DBUSMALLINT line;
  723. {
  724.    if (severity)
  725.       printf("nDB-LIB message: %s n", msgtext);
  726.    return (0);
  727. };
  729. INT err_handler(dbproc, severity, herrno, oserr, dberrstr, oserrstr)
  730. PDBPROCESS  dbproc;
  731. INT     severity;
  732. INT  herrno;
  733. INT  oserr;
  734. LPCSTR  dberrstr;
  735. LPCSTR  oserrstr;
  736. {
  737. if (severity)
  738.       printf("nDB-LIBRARY error: %s n", dberrstr);
  739.     return (INT_CANCEL);
  740. };