home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / fm2000 / operate.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-04  |  15.1 KB  |  601 lines
  1. /*
  2.      Filemaster - Multitasking directory utility.
  3.      Copyright (C) 2000  Toni Wilen
  4.      
  5.      This program is free software; you can redistribute it and/or
  6.      modify it under the terms of the GNU General Public License
  7.      as published by the Free Software Foundation; either version 2
  8.      of the License, or (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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. */
  19.  
  20. #include <proto/all.h>
  21. #include <exec/types.h>
  22. #include <exec/memory.h>
  23. #include <exec/execbase.h>
  24. #include <exec/resident.h>
  25. #include <exec/io.h>
  26. #include <devices/trackdisk.h>
  27. #include <intuition/intuition.h>
  28. #include <dos/dos.h>
  29. #include <dos/dosextens.h>
  30. #include <dos/filehandler.h>
  31. #include <stdio.h>
  32. #include <string.h>
  33. #include "fmnode.h"
  34. #include "child.h"
  35. #include "fmdos.h"
  36. #include "fmlocale.h"
  37. #include "fmgui.h"
  38.  
  39. struct OperateConfig {
  40.     unsigned fffs:1;
  41.     unsigned fint:1;
  42.     unsigned fdir:1;
  43.     unsigned fver:1;
  44. };
  45. extern UBYTE hsparwed[];
  46.  
  47. WORD format(struct FMList*,struct FMNode*,UBYTE*,struct CMenuConfig *cmc);
  48. WORD openicon(struct FMList*);
  49. WORD diskio(struct FMList*,struct IOStdReq*);
  50. void __asm bootsum(register __a0 UBYTE *);
  51. void drives(struct FMList*);
  52.  
  53. static ULONG bootblock[]=
  54.     {
  55.     0x00000370,0x43fa003e,0x70254eae,0xfdd84a80,
  56.     0x670c2240,0x08e90006,0x00224eae,0xfe6243fa,0x00184eae,0xffa04a80,
  57.     0x670a2040,0x20680016,0x70004e75,0x70ff4e75,0x646f732e,0x6c696272,
  58.     0x61727900,0x65787061,0x6e73696f,0x6e2e6c69,0x62726172,0x79000000
  59.     };
  60.  
  61. extern struct FMMain fmmain;
  62. extern struct FMList fmlist[];
  63. extern struct FMConfig *fmconfig;
  64.  
  65. static WORD createoperatewindow(UBYTE *title,struct FMNode *node,UBYTE *string1,UBYTE *string2,UBYTE *string3,UWORD cdir,BOOL bprot[])
  66. {
  67. struct GUIBase *gb;
  68. WORD cnt2,cnt3,dev=0;
  69. ULONG prot;
  70. struct DosList *doslist;
  71. struct FileSysStartupMsg *fssm;
  72. struct DosEnvec *de;
  73. UBYTE devname[32];
  74.  
  75. gb=getguibase(title);
  76.  
  77. strcpy(string1,NDFILE(node));
  78. strcpy(string2,NDCOMM(node));
  79. if(node->flags&NDEVICE) dev=1;
  80.  
  81. if (dev) string2[strlen(string2)-1]=0;
  82. setconnectgroup(gb,9,0,0);
  83.  
  84. setconnectgroup(gb,1,1,9);
  85. reqinfomsg(gb,MSG_OPERATE_ASKNAME,100,guiUC|guiLEFT);
  86. if(!dev) {
  87.     reqinfomsg(gb,MSG_OPERATE_ASKFLAGS,101,guiLEFT|guiUC);
  88.     reqinfomsg(gb,MSG_OPERATE_ASKCOMMENT,102,guiLEFT|guiUC);
  89.     reqinfomsg(gb,MSG_OPERATE_ASKDATE,103,guiLEFT|guiUC);
  90. }
  91.  
  92. setconnectgroup(gb,2,1,9);
  93. reqstring(gb,100,dev?string2:string1,30);
  94. if(!dev) {
  95.     setconnectgroup(gb,3,0,2);
  96.     cnt3=128; prot=node->numprot^0x0f;
  97.     for (cnt2=0;cnt2<8;cnt2++) {
  98.         bprot[cnt2]=prot&cnt3?1:0;
  99.         reqtoggle(gb,&hsparwed[cnt2*3],101,guiUC,&bprot[cnt2]);
  100.         cnt3=cnt3>>1;
  101.     }
  102.     setguigroup(gb,2,0);
  103.     reqstring(gb,102,string2,80);
  104.     reqstring(gb,103,string3,32);
  105. }
  106. startbuttonbar(gb);
  107. reqbuttonmsg(gb,MSG_OK,1,guiUC);
  108. if(!dev) {
  109.     if(cdir&1) reqbuttonmsg(gb,MSG_OPERATE_CREATEICON,2,guiUC);
  110.     if(cdir&2) reqbuttonmsg(gb,MSG_ALL,3,guiUC);
  111. } else {
  112.     strcpy(devname,NDFILE(node));
  113.     devname[strlen(devname)-1]=0;
  114.     doslist=LockDosList(LDF_DEVICES|LDF_READ);
  115.     doslist=FindDosEntry(doslist,devname,LDF_DEVICES);
  116.     fssm=(struct FileSysStartupMsg*)(doslist->dol_misc.dol_handler.dol_Startup<<2);
  117.     if(fssm) {
  118.         de=(struct DosEnvec*)(fssm->fssm_Environ<<2);
  119.         if(de->de_Surfaces*de->de_BlocksPerTrack*(de->de_HighCyl+1)*de->de_SizeBlock<786432) {
  120.             reqbuttonmsg(gb,MSG_OPERATE_FORMATINSTALL,4,guiUC);
  121.         }
  122.     UnLockDosList(LDF_DEVICES|LDF_READ);
  123.     }
  124. }
  125. reqbuttonmsg(gb,MSG_CANCEL,0,guiUC);
  126. return(quickreq(gb));
  127. }
  128.  
  129. static WORD operoi(struct FMList *list,struct FMNode *node,UBYTE *name,UBYTE *comm,ULONG date,BOOL bprot[],WORD pmode)
  130. {
  131. WORD cnt3,cnt2;
  132. ULONG prot;
  133.  
  134. node->flags&=~NSELECTED;
  135. if (name&&!(fmrename(list,node,name))) return(0);
  136. if (comm&&!(fmcomment(list,node,comm))) return(0);
  137. if (!fmfiledate(list,node,date)) return(0);
  138. if (!pmode) return(1);
  139. if(pmode==1)
  140.     prot=0;
  141.     else
  142.     prot=node->numprot^0x0f;
  143. cnt3=128;
  144. for(cnt2=0;cnt2<8;cnt2++) {
  145.     if (bprot[cnt2]) {
  146.         switch(pmode) {
  147.             case 1:
  148.             case 2:
  149.             prot|=cnt3;
  150.             break;
  151.             case 3:
  152.             prot&=~cnt3;
  153.             break;
  154.         }
  155.     }
  156.     cnt3>>=1;
  157. }
  158. prot=prot^0x0f;
  159. if (!(fmprotect(list,node,prot))) return(0);
  160. return(1);
  161. }
  162.  
  163.  
  164. // combined Rename/Comment/Protect
  165.  
  166. void __saveds operate(void)
  167. {
  168. struct ProcMsg *pm;
  169. struct GUIBase *gb;
  170. BOOL bprot[8];
  171. struct FMList *list;
  172. struct FMNode *node;
  173. struct FMNode *node2;
  174. UBYTE string1[32];
  175. UBYTE string2[80];
  176. UBYTE string3[32];
  177. WORD ccom,cflags,cdate;
  178. ULONG date;
  179. WORD cnt2;
  180. WORD ret;
  181.  
  182. pm=sinitproc();
  183. list=fmmain.sourcedir;
  184. node2=list->lastclicked;
  185. list->lastclicked=0;
  186. if (!(setalloc(list,1))) {
  187.     initproc(0,0); 
  188.     goto endi;
  189. }
  190. initproc(list,pm->cmc->label);
  191. if(!node2&&!findselnodeall(list)) {
  192.     strcpymsg(list->fmmessage1,MSG_MAIN_NOSOURCEFILE);
  193.     fmmessage(list);
  194. }
  195. for(;;) {
  196.     if (node2) {
  197.         node=node2;
  198.     } else {
  199.         node=findselnodeall(list);
  200.     }
  201.     if(!node) break;
  202.     endofdirtxt(list,node);
  203.     if(node->flags&NASSIGN) {
  204.         node->flags&=~NSELECTED;
  205.         outputlistline(list,node);
  206.         break;
  207.     }
  208.     longtodatestring(string3,node->numdate);
  209.     cnt2=createoperatewindow(list->workname,node,string1,string2,string3,2,bprot);
  210.     if(!cnt2) break;
  211.     date=datestringtolong(string3);
  212.  
  213.     if (cnt2==4) {
  214.         format(list,node,string2,pm->cmc);
  215.         node->flags&=~NSELECTED;
  216.         break;
  217.     }
  218.     if (cnt2==3) {
  219.             gb=getguibase(list->workname);
  220.             cflags=0;ccom=0;cdate=0;
  221.             setconnectgroup(gb,1,0,0);
  222.             reqinfomsg(gb,MSG_OPERATE_ASKFLAGS,100,guiUC|guiLEFT);
  223.             reqcyclemsg(gb,100,&cflags,MSG_NON,MSG_OPERATE_CHANGE,MSG_OPERATE_ADD,MSG_OPERATE_SUB,0);
  224.             setconnectgroup(gb,2,0,0);
  225.             reqinfomsg(gb,MSG_OPERATE_ASKCOMMENT,101,guiUC|guiLEFT);
  226.             reqcyclemsg(gb,101,&ccom,MSG_NON,MSG_OPERATE_CHANGE,0);
  227.             setconnectgroup(gb,3,0,0);
  228.             reqinfomsg(gb,MSG_OPERATE_ASKDATE,102,guiUC|guiLEFT);
  229.             reqcyclemsg(gb,102,&cdate,MSG_NON,MSG_OPERATE_CHANGE,0);
  230.             buttonbarmsg(gb,MSG_OK,1,MSG_CANCEL,0,0);
  231.             ret=quickreq(gb);
  232.             if(ret==1) {
  233.                 while(node=findselnodeall(list)) {
  234.                     node->flags&=~NSELECTED;
  235.                     if(!operoi(list,node,0,ccom?string2:0,cdate?date:0xffffffff,bprot,cflags)) goto opend;
  236.                     outputlistline(list,node);
  237.                 }
  238.                 endofdirtxt(list,node);
  239.             }
  240.             goto opend;
  241.     }
  242.     if (cnt2==1) {
  243.         if (list->flags&LDIRLIST) {
  244.             if(!operoi(list,node,string1,string2,date,bprot,1)) goto opend;
  245.         } else if (node->flags&NDEVICE) {
  246.             if (!Relabel(NDFILE(node),string2)) {
  247.                 dosrequestmsg(list,0,MSG_FMDOS_RELABELERR,NDCOMM(node));
  248.                 break;
  249.             } else {
  250.                 sformat(NDCOMM(node),"%s:",string2);
  251.             }
  252.         }
  253.     }
  254.     node->flags&=~NSELECTED;
  255.     endofdirtxt(list,node);
  256.     outputlistline(list,node);
  257.     if (node2) break;
  258. }
  259. opend:
  260. csortlist(list);
  261. fmmessage(list);
  262. outputlist(list);
  263. endproc(list);
  264. endi:
  265. deinitproc(pm);
  266. }
  267.  
  268. void __saveds createdir(void)
  269. {
  270. struct ProcMsg *pm;
  271. struct FMList *list;
  272. struct FMNode *node=0,*node2=0;
  273. struct DiskObject *dob;
  274. UBYTE string1[32];
  275. UBYTE string2[80];
  276. UBYTE string3[32];
  277. ULONG prot,date;
  278. WORD cnt2,cnt3;
  279. UBYTE vstring[40];
  280. BOOL bprot[8];
  281.  
  282. pm=sinitproc();
  283. list=fmmain.sourcedir;
  284. if (!(setalloc(list,1))) {
  285.     initproc(0,0); 
  286.     goto endi;
  287. }
  288. initproc(list,pm->cmc->label);
  289. priority(pm->cmc);
  290. if(!sselected(list,0)) goto crerr;
  291. if (!(node=allocnode())) {
  292.     endproc(list);
  293.     goto endi;
  294. }
  295. string3[0]=0;
  296. cnt2=createoperatewindow(list->workname,node,string1,string2,string3,1,bprot);
  297. date=datestringtolong(string3);
  298. freevecpooled(node); node=0;
  299. if (cnt2&&string1[0]) {
  300.     if (node=fmcreatedir(list,string1)) {
  301.         if(cnt2==2) {
  302.             if(openicon(list)) {
  303.                 dob=GetDefDiskObject(WBDRAWER);
  304.                 if(!dob) {
  305.                     requestmsg(list->workname,0,MSG_OK,MSG_FMDOS_OPENERR,getstring(MSG_OPERATE_DEFAULTDRAWER));
  306.                 } else {
  307.                     if(PutDiskObject(string1,dob)) {
  308.                         node2=dupnode(node);
  309.                         if(node2) {
  310.                             node2->flags|=NFILE;
  311.                             node2->flags&=~NDIRECTORY;
  312.                             strcpy(vstring,string1);
  313.                             strcpy(vstring+strlen(vstring),".info");
  314.                             strncpy(NDFILE(node2),vstring,fmmain.filelen);
  315.                         }
  316.                     } else {
  317.                         dosrequestmsg(list,0,MSG_FMDOS_WRITEERR,getstring(MSG_OPERATE_DEFAULTDRAWER));
  318.                     }
  319.                     FreeDiskObject(dob);
  320.                 }
  321.             }
  322.         }
  323.         cnt3=128; prot=0;
  324.         for(cnt2=0;cnt2<8;cnt2++) {
  325.             if (bprot[cnt2]) prot|=cnt3;
  326.             cnt3>>=1;
  327.         }
  328.         prot=prot^0x0f;
  329.         fmprotect(list,node,prot);
  330.         fmcomment(list,node,string2);
  331.         fmfiledate(list,node,date);
  332.         if(node2) {
  333.             fmprotect(list,node2,prot);
  334.             fmcomment(list,node2,string2);
  335.             fmfiledate(list,node2,date);
  336.         }
  337.         node->flags&=~NSELECTED;
  338.         if(node2) node2->flags&=~NSELECTED;
  339.     }
  340. }
  341. fmmessage(list);
  342. crerr:
  343. if(node) {
  344.     examinefile(list,node);
  345.     AddTail((struct List*)list,(struct Node*)node);
  346. }
  347. if(node2) {
  348.     examinefile(list,node2);
  349.     AddTail((struct List*)list,(struct Node*)node2);
  350. }
  351. if(node) endofdirtxt(list,node);
  352. csortlist(list);
  353. parselist(list,0);
  354. outputlist(list);
  355. updadirmeter(list);
  356. endproc(list);
  357. endi:
  358. deinitproc(pm);
  359. }
  360.  
  361. WORD format(struct FMList *list,struct FMNode *node,UBYTE *name,struct CMenuConfig *cmc)
  362. {
  363. struct GUIBase *gb;
  364. struct OperateConfig *operateconfig;
  365. WORD ret;
  366. struct DosList *doslist;
  367. struct FileSysStartupMsg *fssm;
  368. struct DosEnvec *de;
  369. struct Resident *res1;
  370. struct Resident *res2;
  371. struct IOStdReq *ioreq=0;
  372. UBYTE devname[32];
  373. APTR seglist;
  374. WORD romfs=0,jatko=0;
  375. ULONG dostype;
  376. UBYTE dt;
  377. WORD mver,mffs,mint,mdir;
  378. WORD trackcnt,surfacecnt;
  379. UBYTE *formatdata=0,*verifydata=0;
  380. LONG formatlen,cylcnt;
  381. UBYTE *apuptr;
  382. LONG apu1;
  383.  
  384. mffs=mint=0;
  385.  
  386. operateconfig=getconfig(cmc);
  387. if(*name==0) strcpymsg(name,MSG_OPERATE_DEFAULTNAME);
  388. gb=getguibase(cmc->label);
  389.  
  390. setconnectgroup(gb,1,0,0);
  391. reqinfomsg(gb,MSG_OPERATE_ASKNAME,101,guiUC|guiLEFT);
  392. reqstring(gb,101,name,30);
  393. mver=operateconfig->fver;
  394. reqtogglemsg(gb,MSG_OPERATE_VERIFY,102,guiUC,&mver);
  395.  
  396. doslist=LockDosList(LDF_DEVICES|LDF_READ);
  397. strcpy(devname,NDFILE(node));
  398. devname[strlen(devname)-1]=0;
  399. doslist=FindDosEntry(doslist,devname,LDF_DEVICES);
  400. res1=FindResident("filesystem");
  401. res2=FindResident("fastfilesystem");
  402. fssm=(struct FileSysStartupMsg*)(doslist->dol_misc.dol_handler.dol_Startup<<2);
  403. de=(struct DosEnvec*)(fssm->fssm_Environ<<2);
  404. dostype=de->de_DosType;
  405. seglist=(APTR)(doslist->dol_misc.dol_handler.dol_SegList<<2);
  406. mdir=0;
  407. if(res1&&seglist==res1->rt_Init||res2&&seglist==res2->rt_Init) {
  408.     setconnectgroup(gb,2,0,0);
  409.     romfs=1;
  410.     mffs=operateconfig->fffs;
  411.     reqtogglemsg(gb,MSG_OPERATE_FFS,103,guiUC,&mffs);
  412.     mint=operateconfig->fint;
  413.     reqtogglemsg(gb,MSG_OPERATE_INT,104,guiUC,&mint);
  414.     #ifdef V39
  415.     mdir=operateconfig->fdir;
  416.     reqtogglemsg(gb,MSG_OPERATE_DIRCACHE,105,guiUC,&mdir);
  417.     #endif
  418. }
  419. UnLockDosList(LDF_DEVICES|LDF_READ);
  420. buttonbarmsg(gb,MSG_OPERATE_DOFORMAT,1,MSG_OPERATE_DOQFORMAT,2,MSG_OPERATE_DOINSTALL,3,MSG_CANCEL,0,0);
  421.  
  422. ret=quickreq(gb);
  423. if(!ret) return(0);
  424. operateconfig->fver=mver;
  425. operateconfig->fffs=mffs;
  426. operateconfig->fint=mint;
  427. operateconfig->fdir=mdir;
  428. if(!Inhibit(NDFILE(node),DOSTRUE)) {
  429.     dosrequestmsg(list,0,MSG_OPERATE_INHIBITERR);
  430.     return(0);
  431. }
  432. list->fmmessage2[0]=0;
  433.  
  434. if(ret==1) {
  435.     formatlen=de->de_SizeBlock*de->de_BlocksPerTrack*4;
  436.     apuptr=formatdata=allocvec(list,formatlen,MEMF_PUBLIC);
  437.     if(!formatdata) goto fend;
  438.     if(operateconfig->fver) {
  439.         verifydata=allocvec(list,formatlen,MEMF_PUBLIC);
  440.         if(!verifydata) goto fend;
  441.     }
  442.     apu1=formatlen;
  443.     while(apu1!=0) {
  444.         *(ULONG*)apuptr='FM30';
  445.         apuptr+=4;
  446.         apu1-=4;
  447.     }    
  448.     *(ULONG*)formatdata=0x42414400;    //BAD0
  449.     ioreq=(struct IOStdReq*)opendevice(list,(UBYTE*)(fssm->fssm_Device<<2)+1,fssm->fssm_Unit,fssm->fssm_Flags,sizeof(struct IOStdReq));
  450.     if(!ioreq) goto fend;
  451.     list->fmmessage2[0]=0;
  452.     ioreq->io_Command=TD_FORMAT;
  453.     ioreq->io_Offset=0;
  454.     ioreq->io_Data=formatdata;
  455.     ioreq->io_Length=formatlen;
  456.     if(!diskio(list,ioreq)) goto fend;
  457.     *((ULONG*)formatdata)='FM30';
  458.     surfacecnt=de->de_Surfaces; trackcnt=de->de_HighCyl;
  459.     cylcnt=(surfacecnt*trackcnt+1)*formatlen;
  460.     surfacecnt--;
  461.     while(cylcnt>=0) {
  462.         sformat(list->fmmessage1,getstring(MSG_OPERATE_FORMATTING),trackcnt,surfacecnt);
  463.         fmmessage(list);
  464.         ioreq->io_Offset=cylcnt;
  465.         ioreq->io_Data=formatdata;
  466.         ioreq->io_Length=formatlen;
  467.         ioreq->io_Command=TD_FORMAT;
  468.         if(!diskio(list,ioreq)) goto fend;
  469.         if(operateconfig->fver) {
  470.             sformat(list->fmmessage1,getstring(MSG_OPERATE_VERIFYING),trackcnt,surfacecnt);
  471.             fmmessage(list);
  472.             ioreq->io_Offset=cylcnt;
  473.             ioreq->io_Data=verifydata;
  474.             ioreq->io_Length=formatlen;
  475.             ioreq->io_Command=CMD_READ;
  476.             if(!diskio(list,ioreq)) goto fend;
  477.         }
  478.         if(testabort(list)) {
  479.             ioreq->io_Command=TD_MOTOR;
  480.             ioreq->io_Length=0;
  481.             if (!diskio(list,ioreq)) goto fend;
  482.             if (askabort(list)) {
  483.                 ret=0;
  484.                 break;
  485.             }
  486.         }
  487.         cylcnt-=formatlen;
  488.         if(--surfacecnt<0) {
  489.             surfacecnt=de->de_Surfaces-1;
  490.             trackcnt--;
  491.         }
  492.     }
  493.     ioreq->io_Command=CMD_UPDATE;
  494.     if (!diskio(list,ioreq)) goto fend;
  495.     jatko=1;
  496. }
  497.  
  498. if(ret==1||ret==2) {
  499.     closedevice((struct IORequest*)ioreq); ioreq=0;
  500.     if(romfs) {
  501.         dt=operateconfig->fffs|(operateconfig->fint<<1)|(operateconfig->fdir<<2);
  502.         if(dt>=6) dt-=2;
  503.         dostype=0x444f5300|dt;
  504.     }
  505.     strcpymsg(list->fmmessage1,MSG_OPERATE_INITIALIZING);
  506.     fmmessage(list);
  507.     if (!Format(NDFILE(node),name,dostype)) {
  508.         dosrequestmsg(list,0,MSG_OPERATE_INITIALIZEERR);
  509.         goto fend;
  510.     }
  511.     jatko=1;
  512. }
  513.  
  514. if(ret==3||jatko) {
  515.     strcpymsg(list->fmmessage1,MSG_OPERATE_INSTALLING);
  516.     fmmessage(list);
  517.     formatlen=de->de_SizeBlock*4;
  518.     formatdata=allocvec(list,formatlen,MEMF_PUBLIC);
  519.     if(!formatdata) goto fend;
  520.     ioreq=(struct IOStdReq*)opendevice(list,(UBYTE*)(fssm->fssm_Device<<2)+1,fssm->fssm_Unit,fssm->fssm_Flags,48);
  521.     if(!ioreq) goto fend;
  522.     ioreq->io_Command=CMD_READ;
  523.     ioreq->io_Offset=0;
  524.     ioreq->io_Data=formatdata;
  525.     ioreq->io_Length=formatlen;
  526.     if (diskio(list,ioreq)) {
  527.         memseti(formatdata+4,0,formatlen-4);
  528.         if(formatdata[0]=='D'&&formatdata[1]=='O'&&formatdata[2]=='S') {
  529.             CopyMem(bootblock,formatdata+8,sizeof(bootblock));
  530.             bootsum(formatdata);
  531.             ioreq->io_Command=CMD_WRITE;
  532.             ioreq->io_Offset=0;
  533.             ioreq->io_Data=formatdata;
  534.             ioreq->io_Length=formatlen;
  535.             diskio(list,ioreq);
  536.         } else {
  537.             if(!jatko) {
  538.                 requestmsg(list->workname,0,MSG_OK,MSG_OPERATE_INSTALLERR);
  539.             }
  540.         }
  541.     }
  542. }
  543. fend:
  544. freemem(formatdata);
  545. freemem(verifydata);
  546. ioreq->io_Command=CMD_UPDATE;
  547. diskio(list,ioreq);
  548. closedevice((struct IORequest*)ioreq);
  549. Inhibit(NDFILE(node),FALSE);
  550. list->fmmessage1[0]=0;
  551. list->fmmessage2[0]=0;
  552. fmmessage(list);
  553. updadirmeter(list);
  554. for(ret=0;ret<LISTS;ret++) {
  555.     if (fmlist[ret].flags&LDEVLIST) drives(&fmlist[ret]);
  556. }
  557. return(1);
  558. }
  559.  
  560. WORD diskio(struct FMList *list,struct IOStdReq *req)
  561. {
  562. UBYTE ret;
  563. WORD cnt;
  564. WORD ocommand;
  565. LONG olength;
  566. UBYTE *errtxt;
  567.  
  568. ocommand=req->io_Command;
  569. olength=req->io_Length;
  570. do {
  571.     req->io_Command=ocommand;
  572.     req->io_Length=olength;
  573.     DoIO((struct IORequest*)req);
  574.     ret=req->io_Error;
  575.     if(!ret) return(1);
  576.     req->io_Command=TD_MOTOR;
  577.     req->io_Length=0;
  578.     DoIO((struct IORequest*)req);
  579.     errtxt=getstring(MSG_DEVICE_ERRORS);
  580.     for(cnt=20;cnt<36;cnt++) {
  581.         if(cnt==ret) break;
  582.         errtxt+=strlen(errtxt)+1;
  583.     }
  584.     if(ret==252) errtxt+=strlen(errtxt)+1;
  585. } while(requestmsg(list->workname,MSG_RETRY,MSG_CANCEL,MSG_DEVICE_ERROR,errtxt,ret));
  586. return(0);
  587. }
  588.  
  589. void *operateconfigdefault(struct CMenuConfig *cmc)
  590. {
  591. struct OperateConfig *config;
  592. WORD ret;
  593.  
  594. ret=allocconfig(cmc,sizeof(struct OperateConfig));
  595. if(ret<0) return(cmc->moreconfig);
  596. if(!ret) return(0);
  597. config=(struct OperateConfig*)cmc->moreconfig;
  598. config->fffs=1;
  599. return(cmc->moreconfig);
  600. }
  601.