scalos/main/DevListClass.c

   1 // DevListClass.c
   2 // $Date$
   3 // $Revision$
   4
   5
   6 #include <exec/types.h>
   7 #include <intuition/classes.h>
   8 #include <intuition/classusr.h>
   9 #include <utility/hooks.h>
  10 #include <intuition/gadgetclass.h>
  11 #include <workbench/workbench.h>
  12 #include <workbench/startup.h>
  13 #include <dos/dostags.h>
  14 #include <dos/datetime.h>
  15
  16 #define __USE_SYSBASE
  17
  18 #include <proto/dos.h>
  19 #include <proto/exec.h>
  20 #include <proto/layers.h>
  21 #include <proto/intuition.h>
  22 #include <proto/graphics.h>
  23 #include <proto/utility.h>
  24 #include <proto/locale.h>
  25 #include "debug.h"
  26 #include <proto/scalos.h>
  27
  28 #include <clib/alib_protos.h>
  29
  30 #include <defs.h>
  31 #include <datatypes/iconobject.h>
  32 #include <scalos/scalos.h>
  33
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37
  38 #include "scalos_structures.h"
  39 #include "functions.h"
  40 #include "Variables.h"
  41
  42 //----------------------------------------------------------------------------
  43
  44 // local data definitions
  45
  46 struct DevListClassInstance
  47         {
  48         struct MsgPort *dlci_ReplyPort;                 // DosPacket Replyport
  49         struct List dlci_DleList;
  50         struct ScaDeviceIcon *dlci_DevIconList;
  51         };
  52
  53 enum DevListState
  54         {
  55         DLE_Initial,                    // dle has just been created
  56         DLE_WaitInfo,                   // initial SendPkt() is pending, waiting for reply
  57         DLE_WaitInfo2,                  // waiting for SendPkt() reply
  58         DLE_InfoFinished,               // SendPkt() has replied, dle_InfoData is valid
  59         };
  60
  61 struct DevListEntry
  62         {
  63         struct Node dle_Node;
  64         struct InfoData *dle_InfoData;          // Infodata from dos.library/Info()
  65         LONG dle_Type;                          // type of entry, see DLT
  66         struct DosPacket *dle_DosPacket;
  67         struct MsgPort *dle_Handler;            // MessagePort of the HandlerTask
  68         STRPTR dle_DeviceName;                  // Copy of device name (cannot be NULL)
  69         STRPTR dle_VolumeName;                  // Copy of volume name or NULL
  70         enum DevListState dle_State;
  71         ULONG dle_WaitCount;
  72         BOOL dle_MayBeRemoved;
  73         BOOL dle_IconCreated;
  74         };
  75
  76 //----------------------------------------------------------------------------
  77
  78 // local functions
  79
  80 static SAVEDS(IPTR) DevListClass_Dispatcher(Class *cl, Object *o, Msg msg);
  81 static IPTR DevListClass_New(Class *cl, Object *o, Msg msg);
  82 static ULONG DevListClass_Dispose(Class *cl, Object *o, Msg msg);
  83 static ULONG DevListClass_Generate(Class *cl, Object *o, Msg msg);
  84 static ULONG DevListClass_FreeDevNode(Class *cl, Object *o, Msg msg);
  85 static ULONG DevListClass_Filter(Class *cl, Object *o, Msg msg);
  86 static STRPTR AllocCopyBString(BPTR bString);
  87 static STRPTR AllocCopyAString(CONST_STRPTR String);
  88 static void CheckAddDosListEntry(struct DevListClassInstance *inst, struct DosList *dlist);
  89 static void HandleRepliedPackets(Object *o, struct DevListClassInstance *inst, struct ScaDeviceIcon **diList);
  90 static struct DevListEntry *CreateDevListEntry(const struct DosList *dlist);
  91 static void DeleteDevListEntry(struct DevListEntry *dle);
  92 static void CreateDeviceIcons(struct DevListClassInstance *inst, struct ScaDeviceIcon **diList);
  93 static void RemoveObsoleteEntries(struct DevListClassInstance *inst);
  94 static struct ScaDeviceIcon *CreateIconFromDle(struct DevListEntry *dle,
  95         struct ScaDeviceIcon **diList, struct DosList *origDlist);
  96 static void SendInfoPacket(struct DevListClassInstance *inst, struct DevListEntry *dle);
  97 static BOOL VerifyDosListEntry(struct DosList *dlStart, const struct DosList *dlTest);
  98
  99 //----------------------------------------------------------------------------
 100
 101 // public data items :
 102
 103 //----------------------------------------------------------------------------
 104
 105
 106 struct ScalosClass *initDevListClass(const struct PluginClass *plug)
 107 {
 108         struct ScalosClass *DevListClass;
 109
 110         DevListClass = SCA_MakeScalosClass(plug->plug_classname,
 111                         plug->plug_superclassname,
 112                         sizeof(struct DevListClassInstance),
 113                         NULL);
 114
 115         if (DevListClass)
 116                 {
 117                 // initialize the cl_Dispatcher Hook
 118                 SETHOOKFUNC(DevListClass->sccl_class->cl_Dispatcher, DevListClass_Dispatcher);
 119                 }
 120
 121         return DevListClass;
 122 }
 123
 124
 125 static SAVEDS(IPTR) DevListClass_Dispatcher(Class *cl, Object *o, Msg msg)
 126 {
 127         IPTR Result;
 128
 129         switch (msg->MethodID)
 130                 {
 131         case OM_NEW:
 132                 Result = DevListClass_New(cl, o, msg);
 133                 break;
 134
 135         case OM_DISPOSE:
 136                 Result = DevListClass_Dispose(cl, o, msg);
 137                 break;
 138
 139         case SCCM_DeviceList_Generate:
 140                 Result = DevListClass_Generate(cl, o, msg);
 141                 break;
 142
 143         case SCCM_DeviceList_FreeDevNode:
 144                 Result = DevListClass_FreeDevNode(cl, o, msg);
 145                 break;
 146
 147         case SCCM_DeviceList_Filter:
 148                 Result = DevListClass_Filter(cl, o, msg);
 149                 break;
 150
 151         default:
 152                 Result = DoSuperMethodA(cl, o, msg);
 153                 break;
 154                 }
 155
 156         return Result;
 157 }
 158
 159
 160 static IPTR DevListClass_New(Class *cl, Object *o, Msg msg)
 161 {
 162         d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 163
 164         o = (Object *) DoSuperMethodA(cl, o, msg);
 165
 166         if (o)
 167                 {
 168                 struct DevListClassInstance *inst = INST_DATA(cl, o);
 169
 170                 d1(kprintf("%s/%s/%ld: o=%08lx\n", __FILE__, __FUNC__, __LINE__, o));
 171
 172                 inst->dlci_DevIconList = NULL;
 173                 inst->dlci_ReplyPort = CreateMsgPort();
 174                 NewList(&inst->dlci_DleList);
 175
 176                 if (NULL == inst->dlci_ReplyPort)
 177                         {
 178                         DoMethod(o, OM_DISPOSE);
 179                         o = NULL;
 180                         }
 181                 }
 182
 183         return (IPTR) o;
 184 }
 185
 186
 187 static ULONG DevListClass_Dispose(Class *cl, Object *o, Msg msg)
 188 {
 189         struct DevListClassInstance *inst = INST_DATA(cl, o);
 190         struct DevListEntry *dle;
 191
 192         d1(kprintf("%s/%s/%ld\n", __FILE__, __FUNC__, __LINE__));
 193
 194         while ((dle = (struct DevListEntry *) RemHead(&inst->dlci_DleList)))
 195                 {
 196                 switch (dle->dle_State)
 197                         {
 198                 case DLE_WaitInfo:
 199                 case DLE_WaitInfo2:
 200 #ifndef __amigaos4__
 201                         AbortPkt(dle->dle_Handler, dle->dle_DosPacket);
 202 #endif
 203                         break;
 204                 default:
 205                         break;
 206                         }
 207                 DeleteDevListEntry(dle);
 208                 }
 209
 210         if (inst->dlci_ReplyPort)
 211                 {
 212                 DeleteMsgPort(inst->dlci_ReplyPort);
 213                 inst->dlci_ReplyPort = NULL;
 214                 }
 215
 216         return DoSuperMethodA(cl, o, msg);
 217 }
 218
 219
 220 static ULONG DevListClass_Generate(Class *cl, Object *o, Msg msg)
 221 {
 222         struct DevListClassInstance *inst = INST_DATA(cl, o);
 223         struct msg_Generate *mge = (struct msg_Generate *) msg;
 224         struct DosList *dlist, *origDlist;
 225         struct DevListEntry *dle;
 226
 227         for (dle = (struct DevListEntry *) inst->dlci_DleList.lh_Head;
 228                 dle != (struct DevListEntry *) &inst->dlci_DleList.lh_Tail;
 229                 dle = (struct DevListEntry *) dle->dle_Node.ln_Succ)
 230                 {
 231                 switch (dle->dle_State)
 232                         {
 233                 case DLE_WaitInfo:
 234                 case DLE_WaitInfo2:
 235                         dle->dle_WaitCount++;
 236                         break;
 237                 case DLE_Initial:
 238                 case DLE_InfoFinished:
 239                         dle->dle_MayBeRemoved = TRUE;
 240                         break;
 241                         }
 242                 dle->dle_IconCreated = FALSE;
 243                 }
 244
 245         // now handle all device icons whose handlers have finished processing since last call
 246         HandleRepliedPackets(o, inst, mge->mge_DevIconList);
 247
 248         origDlist = AttemptLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 249
 250         // work around bug in AttemptLockDosList()
 251         if ((struct DosList *) 0x00000001 == origDlist)
 252                 origDlist = NULL;
 253
 254         if (origDlist)
 255                 {
 256                 for (dlist=origDlist; dlist; )
 257                         {
 258                         dlist = NextDosEntry(dlist, LDF_VOLUMES);
 259
 260                         CheckAddDosListEntry(inst, dlist);
 261                         }
 262                 for (dlist=origDlist; dlist; )
 263                         {
 264                         dlist = NextDosEntry(dlist, LDF_DEVICES);
 265
 266                         CheckAddDosListEntry(inst, dlist);
 267                         }
 268
 269                 RemoveObsoleteEntries(inst);
 270
 271                 for (dle = (struct DevListEntry *) inst->dlci_DleList.lh_Head;
 272                         dle != (struct DevListEntry *) &inst->dlci_DleList.lh_Tail;
 273                         dle = (struct DevListEntry *) dle->dle_Node.ln_Succ)
 274                         {
 275                         d1(kprintf("%s/%s/%ld: dle=%08lx  dle_DeviceName=%08lx <%s>  dle_VolumeName=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, \
 276                                 dle, dle->dle_DeviceName, dle->dle_DeviceName ? dle->dle_DeviceName : (STRPTR) "",\
 277                                 dle->dle_VolumeName, dle->dle_VolumeName ? dle->dle_VolumeName : (STRPTR) ""));
 278
 279                         if (dle->dle_DeviceName)
 280                                 {
 281                                 switch (dle->dle_State)
 282                                         {
 283                                 case DLE_Initial:
 284                                 case DLE_InfoFinished:
 285                                         SendInfoPacket(inst, dle);
 286                                         break;
 287                                 default:
 288                                         break;
 289                                         }
 290                                 }
 291                         }
 292
 293                 UnLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 294                 }
 295
 296         // now handle all device icons whose handlers were able to reply in time
 297         HandleRepliedPackets(o, inst, mge->mge_DevIconList);
 298
 299         // create ScaDeviceIcon's from inst->dlci_DleList
 300         CreateDeviceIcons(inst, mge->mge_DevIconList);
 301
 302         DoMethod(o, SCCM_DeviceList_Filter, mge->mge_DevIconList);
 303
 304         return 0;
 305 }
 306
 307
 308 static ULONG DevListClass_FreeDevNode(Class *cl, Object *o, Msg msg)
 309 {
 310         struct msg_FreeDevNode *mfd = (struct msg_FreeDevNode *) msg;
 311
 312         if (mfd->mfd_DevIcon->di_NotifyReq.nr_Name)
 313                 {
 314                 ScalosEndNotify(&mfd->mfd_DevIcon->di_NotifyReq);
 315                 memset(&mfd->mfd_DevIcon->di_NotifyReq, 0, sizeof(mfd->mfd_DevIcon->di_NotifyReq));
 316                 }
 317         if (mfd->mfd_DevIcon->di_DiskIconName)
 318                 {
 319                 FreePathBuffer(mfd->mfd_DevIcon->di_DiskIconName);
 320                 mfd->mfd_DevIcon->di_DiskIconName = NULL;
 321                 }
 322         if (mfd->mfd_DevIcon->di_Volume)
 323                 ScalosFree(mfd->mfd_DevIcon->di_Volume);
 324         if (mfd->mfd_DevIcon->di_Device)
 325                 ScalosFree(mfd->mfd_DevIcon->di_Device);
 326
 327         return 0;
 328 }
 329
 330
 331 static ULONG DevListClass_Filter(Class *cl, Object *o, Msg msg)
 332 {
 333         struct msg_Filter *mfi = (struct msg_Filter *) msg;
 334         struct ScaDeviceIcon *di;
 335
 336         for (di=*mfi->mfi_DevIconList; di; di = (struct ScaDeviceIcon *) di->di_Node.mln_Succ)
 337                 {
 338                 d1(kprintf("%s/%s/%ld: <%s>  InfoData=%08lx  diskType=%08lx  Flags=%04lx\n", \
 339                         __FILE__, __FUNC__, __LINE__, di->di_Device, di->di_Info, di->di_Info->id_DiskType, di->di_Flags));
 340
 341                 if ((NULL == di->di_Volume
 342                      && ID_DOS_DISK == (di->di_Info->id_DiskType & 0xffffff00)
 343                     )
 344                     || (MAKE_ID('F','T','X','T') == di->di_Info->id_DiskType)
 345                     || (strcmp(di->di_Device, "ENV:") == 0)
 346                 )
 347                         {
 348                         di->di_Flags |= DIBF_DontDisplay;
 349                         }
 350
 351                 d1(kprintf("%s/%s/%ld: di=%08lx  di_Device=%08lx <%s>  di_Volume=%08lx <%s>  Flags=%04lx\n", __FILE__, __FUNC__, __LINE__, \
 352                         di, di->di_Device, di->di_Device ? di->di_Device : (STRPTR) "",\
 353                         di->di_Volume, di->di_Volume ? di->di_Volume : (STRPTR) "",\
 354                         di->di_Flags));
 355                 }
 356
 357         return 1;
 358 }
 359
 360
 361 static STRPTR AllocCopyBString(BPTR bString)
 362 {
 363 #ifdef __AROS__
 364         // AROS needs special handling because it uses NULL-terminated
 365         // strings on some platforms.
 366         CONST_STRPTR Src = AROS_BSTR_ADDR(bString);
 367         size_t Len = AROS_BSTR_strlen(bString);
 368         STRPTR Name, lp;
 369
 370         Name = lp = ScalosAlloc(Len + 3);
 371         if (NULL == Name)
 372                 return NULL;
 373 #else
 374         CONST_STRPTR Src = BADDR(bString);
 375         size_t Len = *Src;
 376         STRPTR Name, lp;
 377
 378         Name = lp = ScalosAlloc(Len + 3);
 379         if (NULL == Name)
 380                 return NULL;
 381
 382         Len = *Src++;
 383 #endif
 384
 385         while (Len--)
 386                 *lp++ = *Src++;
 387
 388         *lp++ = ':';
 389         *lp = '\0';
 390
 391         return Name;
 392 }
 393
 394
 395 static STRPTR AllocCopyAString(CONST_STRPTR Src)
 396 {
 397         size_t Len;
 398         STRPTR Name;
 399
 400         if (NULL == Src)
 401                 return NULL;
 402
 403         Len = strlen(Src);
 404
 405         Name = ScalosAlloc(1 + Len);
 406         if (NULL == Name)
 407                 return NULL;
 408
 409         strcpy(Name, Src);
 410
 411         return Name;
 412 }
 413
 414
 415 static void CheckAddDosListEntry(struct DevListClassInstance *inst, struct DosList *dlist)
 416 {
 417         if (dlist && dlist->dol_Task)
 418                 {
 419                 BOOL Found = FALSE;
 420                 struct DevListEntry *dle;
 421
 422                 for (dle = (struct DevListEntry *) inst->dlci_DleList.lh_Head;
 423                         dle != (struct DevListEntry *) &inst->dlci_DleList.lh_Tail;
 424                         dle = (struct DevListEntry *) dle->dle_Node.ln_Succ)
 425                         {
 426                         if (dle->dle_Handler == dlist->dol_Task)
 427                                 {
 428                                 dle->dle_MayBeRemoved = FALSE;
 429
 430                                 switch (dlist->dol_Type)
 431                                         {
 432                                 case DLT_VOLUME:
 433                                         if (dle->dle_VolumeName)
 434                                                 ScalosFree(dle->dle_VolumeName);
 435
 436                                         dle->dle_VolumeName = AllocCopyBString(dlist->dol_Name);
 437                                         break;
 438                                 case DLT_DEVICE:
 439                                         if (dle->dle_DeviceName)
 440                                                 ScalosFree(dle->dle_DeviceName);
 441
 442                                         dle->dle_DeviceName = AllocCopyBString(dlist->dol_Name);
 443                                         break;
 444                                         }
 445                                 Found = TRUE;
 446
 447                                 d1(kprintf("%s/%s/%ld: dle=%08lx  <%s>  disktype=%08lx\n", \
 448                                         __FILE__, __FUNC__, __LINE__, dle, dle->dle_DeviceName, dle->dle_InfoData->id_DiskType));
 449                                 break;
 450                                 }
 451                         }
 452                 if (!Found)
 453                         {
 454                         dle = CreateDevListEntry(dlist);
 455                         if (dle)
 456                                 AddTail(&inst->dlci_DleList, &dle->dle_Node);
 457                         }
 458                 }
 459 }
 460
 461
 462 static void HandleRepliedPackets(Object *o, struct DevListClassInstance *inst, struct ScaDeviceIcon **diList)
 463 {
 464         struct DosList *origDlist;
 465
 466         origDlist = AttemptLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 467
 468         // work around bug in AttemptLockDosList()
 469         if ((struct DosList *) 0x00000001 == origDlist)
 470                 origDlist = NULL;
 471
 472         if (origDlist)
 473                 {
 474                 struct StandardPacket *pkt;
 475
 476                 do      {
 477                         pkt = (struct StandardPacket *) GetMsg(inst->dlci_ReplyPort);
 478                         if (pkt)
 479                                 {
 480                                 struct DevListEntry *dle;
 481
 482                                 d1(kprintf("%s/%s/%ld: pkt=%08lx  Res1=%08lx\n", __FILE__, __FUNC__, __LINE__, pkt, pkt->sp_Pkt.dp_Res1));
 483
 484                                 for (dle = (struct DevListEntry *) inst->dlci_DleList.lh_Head;
 485                                         dle != (struct DevListEntry *) &inst->dlci_DleList.lh_Tail;
 486                                         dle = (struct DevListEntry *) dle->dle_Node.ln_Succ)
 487                                         {
 488                                         if (pkt->sp_Pkt.dp_Arg1 == (IPTR) MKBADDR(dle->dle_InfoData))
 489                                                 {
 490                                                 d1(kprintf("%s/%s/%ld: di=%08lx  <%s>  disktype=%08lx\n", \
 491                                                         __FILE__, __FUNC__, __LINE__, dle, dle->dle_DeviceName, dle->dle_InfoData->id_DiskType));
 492
 493                                                 if (!pkt->sp_Pkt.dp_Res1)
 494                                                         dle->dle_InfoData->id_DiskType = ID_NO_DISK_PRESENT;
 495
 496                                                 dle->dle_State = DLE_InfoFinished;
 497                                                 dle->dle_WaitCount = 0;
 498
 499                                                 CreateIconFromDle(dle, diList, origDlist);
 500                                                 }
 501                                         }
 502                                 }
 503                         } while (pkt);
 504
 505                 UnLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 506                 }
 507 }
 508
 509
 510 static struct DevListEntry *CreateDevListEntry(const struct DosList *dlist)
 511 {
 512         struct DevListEntry *dle;
 513
 514         dle = ScalosAlloc(sizeof(struct DevListEntry));
 515         if (dle)
 516                 {
 517                 dle->dle_Type = dlist->dol_Type;
 518                 dle->dle_Handler = dlist->dol_Task;
 519                 dle->dle_State = DLE_Initial;
 520                 dle->dle_MayBeRemoved = FALSE;
 521                 dle->dle_IconCreated = FALSE;
 522                 dle->dle_WaitCount = 0;
 523                 dle->dle_InfoData = ScalosAllocInfoData();
 524                 dle->dle_InfoData->id_DiskType = ID_NO_DISK_PRESENT;
 525                 dle->dle_DosPacket = NULL;
 526                 dle->dle_DeviceName = NULL;
 527                 dle->dle_VolumeName = NULL;
 528
 529                 switch (dlist->dol_Type)
 530                         {
 531                 case DLT_VOLUME:
 532                         dle->dle_VolumeName = AllocCopyBString(dlist->dol_Name);
 533                         break;
 534                 case DLT_DEVICE:
 535                         dle->dle_DeviceName = AllocCopyBString(dlist->dol_Name);
 536                         break;
 537                         }
 538
 539                 dle->dle_DosPacket = AllocDosObject(DOS_STDPKT, NULL);
 540
 541                 if ((NULL == dle->dle_InfoData)
 542                         || (NULL == dle->dle_VolumeName && NULL == dle->dle_DeviceName)
 543                         || (NULL == dle->dle_DosPacket))
 544                         {
 545                         DeleteDevListEntry(dle);
 546                         return NULL;
 547                         }
 548                 }
 549
 550         return dle;
 551 }
 552
 553
 554 static void DeleteDevListEntry(struct DevListEntry *dle)
 555 {
 556         if (dle)
 557                 {
 558                 ScalosFreeInfoData( &dle->dle_InfoData );
 559                 if (dle->dle_DeviceName)
 560                         {
 561                         ScalosFree(dle->dle_DeviceName);
 562                         dle->dle_DeviceName = NULL;
 563                         }
 564                 if (dle->dle_VolumeName)
 565                         {
 566                         ScalosFree(dle->dle_VolumeName);
 567                         dle->dle_VolumeName = NULL;
 568                         }
 569                 if (dle->dle_DosPacket)
 570                         {
 571                         FreeDosObject(DOS_STDPKT, dle->dle_DosPacket);
 572                         dle->dle_DosPacket = NULL;
 573                         }
 574
 575                 ScalosFree(dle);
 576                 }
 577 }
 578
 579
 580 static void CreateDeviceIcons(struct DevListClassInstance *inst, struct ScaDeviceIcon **diList)
 581 {
 582         struct DosList *origDlist;
 583
 584         origDlist = AttemptLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 585
 586         // work around bug in AttemptLockDosList()
 587         if ((struct DosList *) 0x00000001 == origDlist)
 588                 origDlist = NULL;
 589
 590         if (origDlist)
 591                 {
 592                 struct DevListEntry *dle;
 593
 594                 d1(kprintf("%s/%s/%ld\n", __FILE__, __FUNC__, __LINE__));
 595
 596                 for (dle = (struct DevListEntry *) inst->dlci_DleList.lh_Head;
 597                         dle != (struct DevListEntry *) &inst->dlci_DleList.lh_Tail;
 598                         dle = (struct DevListEntry *) dle->dle_Node.ln_Succ)
 599                         {
 600                         switch (dle->dle_State)
 601                                 {
 602                         case DLE_InfoFinished:
 603                                 CreateIconFromDle(dle, diList, origDlist);
 604                                 break;
 605                         case DLE_WaitInfo2:
 606                                 if (dle->dle_WaitCount < 2)
 607                                         CreateIconFromDle(dle, diList, origDlist);
 608                                 break;
 609                         default:
 610                                 break;
 611                                 }
 612                         }
 613                 UnLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 614                 }
 615 }
 616
 617
 618 // Remove entries from dlci_DleList which are no longer in DosList
 619 static void RemoveObsoleteEntries(struct DevListClassInstance *inst)
 620 {
 621         struct DevListEntry *dle, *dleNext;
 622
 623         d1(kprintf("%s/%s/%ld\n", __FILE__, __FUNC__, __LINE__));
 624
 625         for (dle = (struct DevListEntry *) inst->dlci_DleList.lh_Head;
 626                 dle != (struct DevListEntry *) &inst->dlci_DleList.lh_Tail;
 627                 dle = dleNext)
 628                 {
 629                 dleNext = (struct DevListEntry *) dle->dle_Node.ln_Succ;
 630
 631                 d1(kprintf("%s/%s/%ld: dle=%08lx  <%s>  state=%ld  MayBeRemoved=%ld\n", \
 632                         __FILE__, __FUNC__, __LINE__, dle, dle->dle_DeviceName, dle->dle_State, dle->dle_MayBeRemoved));
 633
 634                 if (dle->dle_MayBeRemoved)
 635                         {
 636                         d1(kprintf("%s/%s/%ld: di=%08lx  Device=<%s>  Volume=<%s> DiskType=%08lx\n", \
 637                                 __FILE__, __FUNC__, __LINE__, dle, dle->dle_DeviceName, dle->dle_VolumeName, dle->dle_InfoData->id_DiskType));
 638
 639                         Remove(&dle->dle_Node);
 640                         DeleteDevListEntry(dle);
 641                         }
 642                 }
 643 }
 644
 645
 646 static struct ScaDeviceIcon *CreateIconFromDle(struct DevListEntry *dle,
 647         struct ScaDeviceIcon **diList, struct DosList *origDlist)
 648 {
 649         struct ScaDeviceIcon *di = NULL;
 650
 651         if (dle->dle_DeviceName && !dle->dle_IconCreated &&
 652                 ID_NO_DISK_PRESENT != dle->dle_InfoData->id_DiskType)
 653                 {
 654                 for (di=*diList; di; di = (struct ScaDeviceIcon *) di->di_Node.mln_Succ)
 655                         {
 656                         if (di->di_Handler == dle->dle_Handler)
 657                                 dle->dle_IconCreated = TRUE;
 658                         }
 659
 660                 if (!dle->dle_IconCreated)
 661                         {
 662                         di = (struct ScaDeviceIcon *) SCA_AllocStdNode((struct ScalosNodeList *) diList, NTYP_DeviceIcon);
 663                         if (di)
 664                                 {
 665                                 struct DosList *dlist;
 666
 667                                 di->di_Info = BADDR(MKBADDR(di->di_InfoBuf + 3));
 668                                 *di->di_Info = *dle->dle_InfoData;
 669                                 di->di_Handler = dle->dle_Handler;
 670
 671                                 dlist = BADDR(di->di_Info->id_VolumeNode);
 672                                 d1(kprintf("%s/%s/%ld: dlist=%08lx\n", __FILE__, __FUNC__, __LINE__, dlist));
 673
 674                                 if (VerifyDosListEntry(origDlist, dlist) && dlist->dol_Name)
 675                                         {
 676                                         // Update volume name from DosList entry pointed to by InfoData
 677                                         d1(kprintf("%s/%s/%ld: dol_Name=%08lx\n", __FILE__, __FUNC__, __LINE__, dlist->dol_Name));
 678                                         if (dle->dle_VolumeName)
 679                                                 ScalosFree(dle->dle_VolumeName);
 680
 681                                         dle->dle_VolumeName = AllocCopyBString(dlist->dol_Name);
 682                                         }
 683
 684                                 d1(kprintf("%s/%s/%ld: dlist=%08lx\n", __FILE__, __FUNC__, __LINE__, dlist));
 685                                 di->di_Volume = AllocCopyAString(dle->dle_VolumeName);
 686                                 d1(kprintf("%s/%s/%ld: dlist=%08lx\n", __FILE__, __FUNC__, __LINE__, dlist));
 687                                 di->di_Device = AllocCopyAString(dle->dle_DeviceName);
 688
 689                                 d1(kprintf("%s/%s/%ld: di=%08lx  Device=<%s>  Volume=<%s> DiskType=%08lx\n", \
 690                                         __FILE__, __FUNC__, __LINE__, dle, dle->dle_DeviceName, dle->dle_VolumeName, dle->dle_InfoData->id_DiskType));
 691
 692                                 if (DLE_WaitInfo2 == dle->dle_State)
 693                                         di->di_Flags |= DIBF_InfoPending;
 694
 695                                 dle->dle_IconCreated = TRUE;
 696                                 }
 697                         }
 698                 }
 699
 700         return di;
 701 }
 702
 703
 704 static void SendInfoPacket(struct DevListClassInstance *inst, struct DevListEntry *dle)
 705 {
 706         struct DosList *origDlist = NULL;
 707         STRPTR DeviceName;
 708
 709         d1(kprintf("%s/%s/%ld: dle=%08lx  <%s>  packet=%08lx\n", \
 710                 __FILE__, __FUNC__, __LINE__, dle, dle->dle_DeviceName, dle->dle_DosPacket));
 711
 712         do      {
 713                 struct DosList *dList;
 714
 715                 DeviceName = AllocCopyString(dle->dle_DeviceName);
 716                 if (NULL == DeviceName)
 717                         break;
 718                 StripTrailingColon(DeviceName);
 719
 720                 origDlist = AttemptLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 721                 if (NULL == origDlist)
 722                         break;
 723
 724                 dList = FindDosEntry(origDlist, DeviceName, LDF_VOLUMES | LDF_DEVICES);
 725                 if (NULL == dList)
 726                         {
 727                         dle->dle_MayBeRemoved = TRUE;
 728                         break;
 729                         }
 730
 731                 dle->dle_DosPacket->dp_Port = inst->dlci_ReplyPort;
 732                 dle->dle_DosPacket->dp_Type = ACTION_DISK_INFO;
 733                 dle->dle_DosPacket->dp_Res1 = dle->dle_DosPacket->dp_Res2 = 0;
 734                 dle->dle_DosPacket->dp_Arg1 = (SIPTR) MKBADDR(dle->dle_InfoData);
 735
 736                 SendPkt(dle->dle_DosPacket, dle->dle_Handler, inst->dlci_ReplyPort);
 737
 738                 if (DLE_InfoFinished == dle->dle_State)
 739                         dle->dle_State = DLE_WaitInfo2;
 740                 else
 741                         dle->dle_State = DLE_WaitInfo;
 742                 } while (0);
 743
 744         if (origDlist)
 745                 UnLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 746
 747         if (DeviceName)
 748                 FreeCopyString(DeviceName);
 749 }
 750
 751
 752 static BOOL VerifyDosListEntry(struct DosList *dlStart, const struct DosList *dlTest)
 753 {
 754         while (dlStart)
 755                 {
 756                 if (dlTest == dlStart)
 757                         return TRUE;
 758
 759                 dlStart = NextDosEntry(dlStart, LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 760                 }
 761
 762         d1(KPrintF("%s/%s/%ld: not found: dlTest=%08lx\n", __FILE__, __FUNC__, __LINE__, dlTest));
 763
 764         return FALSE;   // dlTest not found!
 765 }
 766
 767
 768