rom/workbench/openworkbenchobjecta.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Open a drawer or launch a program.
   6 */
   7 #define DEBUG 0
   8 #include <aros/debug.h>
   9
  10 #include <exec/types.h>
  11 #include <exec/ports.h>
  12 #include <utility/tagitem.h>
  13 #include <intuition/intuition.h>
  14 #include <workbench/workbench.h>
  15 #include <proto/utility.h>
  16 #include <proto/dos.h>
  17
  18 #include <string.h>
  19
  20 #include "workbench_intern.h"
  21 #include "support.h"
  22 #include "support_messages.h"
  23 #include "handler.h"
  24 #include "handler_support.h"
  25
  26 /*** Prototypes *************************************************************/
  27 BOOL   __CLI_LaunchProgram(CONST_STRPTR command, struct TagItem *tags, struct WorkbenchBase *WorkbenchBase);
  28 STRPTR __CLI_BuildCommandLine(CONST_STRPTR command, struct TagItem *tags, struct WorkbenchBase *WorkbenchBase);
  29 BOOL   __WB_LaunchProgram(BPTR lock, CONST_STRPTR name, struct TagItem *tags, struct WorkbenchBase *WorkbenchBase);
  30 BOOL   __WB_BuildArguments(struct WBStartup *startup, BPTR lock, CONST_STRPTR name, struct TagItem *tags, struct WorkbenchBase *WorkbenchBase);
  31
  32 /*** Macros *****************************************************************/
  33 #define CLI_LaunchProgram(name, tags) (__CLI_LaunchProgram((name), (tags), WorkbenchBase))
  34 #define CLI_BuildCommandLine(name, tags) (__CLI_BuildCommandLine((name), (tags), WorkbenchBase))
  35 #define WB_LaunchProgram(lock, name, tags) (__WB_LaunchProgram((lock), (name), (tags), WorkbenchBase))
  36 #define WB_BuildArguments(startup, lock, name, tags) (__WB_BuildArguments((startup), (lock), (name), (tags), WorkbenchBase))
  37
  38 /*****************************************************************************
  39
  40     NAME */
  41
  42         #include <proto/workbench.h>
  43
  44         AROS_LH2(BOOL, OpenWorkbenchObjectA,
  45
  46 /*  SYNOPSIS */
  47         AROS_LHA(STRPTR,           name, A0),
  48         AROS_LHA(struct TagItem *, tags, A1),
  49
  50 /*  LOCATION */
  51         struct WorkbenchBase *, WorkbenchBase, 16, Workbench)
  52
  53 /*  FUNCTION
  54
  55     INPUTS
  56
  57     RESULT
  58
  59     NOTES
  60
  61     EXAMPLE
  62
  63     BUGS
  64
  65     SEE ALSO
  66
  67     INTERNALS
  68
  69 ******************************************************************************/
  70 {
  71     AROS_LIBFUNC_INIT
  72
  73     BOOL                  success       = FALSE;
  74     LONG                  isDefaultIcon = 42;
  75
  76     struct DiskObject    *icon          = GetIconTags
  77     (
  78         name,
  79         ICONGETA_FailIfUnavailable,        FALSE,
  80         ICONGETA_IsDefaultIcon,     (IPTR) &isDefaultIcon,
  81         TAG_DONE
  82     );
  83
  84     ASSERT_VALID_PTR(name);
  85     ASSERT_VALID_PTR_OR_NULL(tags);
  86
  87     D(bug("[WBLIB] OpenWorkbenchObjectA: name = %s\n", name));
  88     D(bug("[WBLIB] OpenWorkbenchObjectA: isDefaultIcon = %ld\n", isDefaultIcon));
  89
  90     if (icon != NULL)
  91     {
  92         switch (icon->do_Type)
  93         {
  94             case WBDISK:
  95             case WBDRAWER:
  96             case WBGARBAGE:
  97                 /*
  98                     Since it's a directory or volume, tell the Workbench
  99                     Application to open the corresponding drawer.
 100                 */
 101
 102                 D(bug("[WBLIB] OpenWorkbenchObjectA: it's a DISK, DRAWER or GARBAGE\n"));
 103
 104                 {
 105                     struct WBCommandMessage *wbcm     = NULL;
 106                     struct WBHandlerMessage *wbhm     = NULL;
 107                     CONST_STRPTR             namecopy = NULL;
 108
 109                     if
 110                     (
 111                            (wbcm     = CreateWBCM(WBCM_TYPE_RELAY)) != NULL
 112                         && (wbhm     = CreateWBHM(WBHM_TYPE_OPEN))  != NULL
 113                         && (namecopy = StrDup(name))                != NULL
 114
 115                     )
 116                     {
 117                         wbhm->wbhm_Data.Open.Name     = namecopy;
 118                         wbcm->wbcm_Data.Relay.Message = wbhm;
 119
 120                         PutMsg(&(WorkbenchBase->wb_HandlerPort), (struct Message *) wbcm);
 121                     }
 122                     else
 123                     {
 124                         FreeVec((STRPTR)namecopy);
 125                         DestroyWBHM(wbhm);
 126                         DestroyWBCM(wbcm);
 127                     }
 128                 }
 129
 130                 break;
 131
 132             case WBTOOL:
 133                 /*
 134                     It's an executable. Before I launch it, I must check
 135                     whether it is a Workbench program or a CLI program.
 136                 */
 137
 138                 D(bug("[WBLIB] OpenWorkbenchObjectA: it's a TOOL\n"));
 139
 140                 if
 141                 (
 142                        !isDefaultIcon
 143                     && FindToolType(icon->do_ToolTypes, "CLI") == NULL
 144                 )
 145                 {
 146                     /* It's a Workbench program */
 147                     BPTR lock = Lock(name, ACCESS_READ);
 148
 149                     D(bug("[WBLIB] OpenWorkbenchObjectA: it's a WB program\n"));
 150
 151                     if (lock != NULL)
 152                     {
 153                         BPTR parent = ParentDir(lock);
 154
 155                         if (parent != NULL)
 156                         {
 157                             IPTR stacksize = icon->do_StackSize;
 158
 159                             if (stacksize < WorkbenchBase->wb_DefaultStackSize)
 160                                 stacksize = WorkbenchBase->wb_DefaultStackSize;
 161
 162                             D(bug("[WBLIB] OpenWorkbenchObjectA: stack size: %d Bytes\n", stacksize));
 163
 164                             struct TagItem wbp_Tags[] =
 165                             {
 166                                 { NP_StackSize, stacksize       },
 167                                 { TAG_MORE, tags                },
 168                                 { TAG_DONE, 0                   }
 169                             };
 170
 171                             if (tags == NULL)
 172                                 wbp_Tags[1].ti_Tag = TAG_IGNORE;
 173
 174                             success = WB_LaunchProgram
 175                             (
 176                                 parent, FilePart(name), wbp_Tags
 177                             );
 178
 179                             if (!success)
 180                             {
 181                                 /*
 182                                     Fallback to launching it as a CLI program.
 183                                     Most likely it will also fail, but we
 184                                     might get lucky.
 185                                 */
 186                                 success = CLI_LaunchProgram(name, wbp_Tags);
 187                             }
 188
 189                             UnLock(parent);
 190                         }
 191
 192                         UnLock(lock);
 193                     }
 194                 }
 195                 else
 196                 {
 197                     /* It's a CLI program */
 198
 199                     D(bug("[WBLIB] OpenWorkbenchObjectA: it's a CLI program\n"));
 200
 201                     success = CLI_LaunchProgram(name, tags);
 202                 }
 203                 break;
 204
 205             case WBPROJECT:
 206                 /* It's a project; try to launch it via its default tool. */
 207
 208                 D(bug("[WBLIB] OpenWorkbenchObjectA: it's a PROJECT\n"));
 209                 D(bug("[WBLIB] OpenWorkbenchObjectA: default tool: %s\n", icon->do_DefaultTool));
 210
 211                 if
 212                 (
 213                        icon->do_DefaultTool != NULL
 214                     && strlen(icon->do_DefaultTool) > 0
 215                 )
 216                 {
 217                     BPTR lock = (BPTR)NULL, parent = (BPTR)NULL;
 218
 219                     lock = Lock(name, ACCESS_READ);
 220                     if (lock != (BPTR)NULL)
 221                         parent = ParentDir(lock);
 222                     if (parent != (BPTR)NULL)
 223                     {
 224                         IPTR stacksize = icon->do_StackSize;
 225
 226                         if (stacksize < WorkbenchBase->wb_DefaultStackSize)
 227                             stacksize = WorkbenchBase->wb_DefaultStackSize;
 228
 229                         D(bug("[WBLIB] OpenWorkbenchObjectA: stack size: %d Bytes\n", stacksize));
 230
 231                         struct TagItem tags[] =
 232                         {
 233                             { NP_StackSize, stacksize                   },
 234                             { WBOPENA_ArgLock, (IPTR) parent            },
 235                             { WBOPENA_ArgName, (IPTR) FilePart(name)    },
 236                             { TAG_DONE, (IPTR)NULL                      }
 237                         };
 238
 239                         if (FindToolType(icon->do_ToolTypes, "CLI") == NULL)
 240                         {
 241                             BPTR lock2 = (BPTR)NULL, parent2 = (BPTR)NULL;
 242
 243                             lock2 = Lock(icon->do_DefaultTool, ACCESS_READ);
 244                             if (lock2 != (BPTR)NULL)
 245                                 parent2 = ParentDir(lock2);
 246                             if (parent2 != NULL)
 247                             {
 248                                 success = WB_LaunchProgram
 249                                 (
 250                                     parent2, FilePart(icon->do_DefaultTool), tags
 251                                 );
 252                             }
 253                             UnLock(parent2);
 254                             UnLock(lock2);
 255                         }
 256                         else
 257                         {
 258                             success = CLI_LaunchProgram
 259                             (
 260                                 icon->do_DefaultTool, tags
 261                             );
 262                         }
 263
 264                         UnLock(parent);
 265                         UnLock(lock);
 266                     }
 267                 }
 268
 269                 if (!success)
 270                 {
 271                     // FIXME: open execute command?
 272                 }
 273                 break;
 274         }
 275
 276         FreeDiskObject(icon);
 277     }
 278     else
 279     {
 280         /*
 281             Getting (a possibly default) icon for the path failed, and
 282             therefore there is no such file. We need to search the default
 283             search path for an executable of that name and launch it. This
 284             only makes sense if the name is *not* an (absolute or relative)
 285             path: that is, it must not contain any ':' or '/'.
 286         */
 287
 288         if (strpbrk(name, "/:") == NULL)
 289         {
 290             struct CommandLineInterface *cli = Cli();
 291             if (cli != NULL)
 292             {
 293                 BPTR *paths;          /* Path list */
 294                 BOOL  running = TRUE;
 295
 296                 /* Iterate over all paths in the path list */
 297                 for
 298                 (
 299                     paths = (BPTR *) BADDR(cli->cli_CommandDir);
 300                     running == TRUE && paths != NULL;
 301                     paths = (BPTR *) BADDR(paths[0]) /* next path */
 302                 )
 303                 {
 304                     BPTR cd   = CurrentDir(paths[1]);
 305                     BPTR lock = Lock(name, SHARED_LOCK);
 306
 307                     if (lock != NULL)
 308                     {
 309                         success = OpenWorkbenchObjectA(name, tags);
 310                         running = FALSE;
 311
 312                         UnLock(lock);
 313                     }
 314
 315                     CurrentDir(cd);
 316                 }
 317             }
 318         }
 319     }
 320
 321     D(bug("[WBLIB] OpenWorkbenchObjectA: success = %d\n", success));
 322
 323     return success;
 324
 325     AROS_LIBFUNC_EXIT
 326 } /* OpenWorkbenchObjectA() */
 327
 328 STRPTR __CLI_BuildCommandLine
 329 (
 330     CONST_STRPTR command, struct TagItem *tags,
 331     struct WorkbenchBase *WorkbenchBase
 332 )
 333 {
 334     const struct TagItem *tstate   = tags;
 335     const struct TagItem *tag      = NULL;
 336     BPTR            lastLock = NULL;
 337     STRPTR          buffer   = NULL;
 338     ULONG           length   = strlen(command) + 3 /* NULL + 2 '"' */;
 339
 340     /*-- Calculate length of resulting string ------------------------------*/
 341     while ((tag = NextTagItem(&tstate)) != NULL)
 342     {
 343         switch (tag->ti_Tag)
 344         {
 345             case WBOPENA_ArgLock:
 346                 lastLock = (BPTR) tag->ti_Data;
 347                 break;
 348
 349             case WBOPENA_ArgName:
 350                 if (lastLock != NULL)
 351                 {
 352                     BPTR cd   = CurrentDir(lastLock);
 353                     BPTR lock = Lock((STRPTR) tag->ti_Data, ACCESS_READ);
 354                     if (lock != NULL)
 355                     {
 356                         STRPTR path = AllocateNameFromLock(lock);
 357                         if (path != NULL)
 358                         {
 359                             length += 3 /* space + 2 '"' */ + strlen(path);
 360                             FreeVec(path);
 361                         }
 362
 363                         UnLock(lock);
 364                     }
 365
 366                     CurrentDir(cd);
 367                 }
 368                 break;
 369         }
 370     }
 371
 372     /*-- Allocate space for command line string ----------------------------*/
 373     buffer = AllocVec(length, MEMF_ANY);
 374
 375     if (buffer != NULL)
 376     {
 377         buffer[0] = '\0';
 378
 379         /*-- Build command line --------------------------------------------*/
 380         strcat(buffer, "\"");
 381         strcat(buffer, command);
 382         strcat(buffer, "\"");
 383
 384         tstate = tags; lastLock = NULL;
 385         while ((tag = NextTagItem(&tstate)) != NULL )
 386         {
 387             switch (tag->ti_Tag)
 388             {
 389                 case WBOPENA_ArgLock:
 390                     lastLock = (BPTR) tag->ti_Data;
 391                     break;
 392
 393                 case WBOPENA_ArgName:
 394                     if (lastLock != NULL)
 395                     {
 396                         BPTR cd   = CurrentDir(lastLock);
 397                         BPTR lock = Lock((STRPTR) tag->ti_Data, ACCESS_READ);
 398                         if (lock != NULL)
 399                         {
 400                             STRPTR path = AllocateNameFromLock(lock);
 401                             if (path != NULL)
 402                             {
 403                                 strcat(buffer, " \"");
 404                                 strcat(buffer, path);
 405                                 strcat(buffer, "\"");
 406                                 FreeVec(path);
 407                             }
 408
 409                             UnLock(lock);
 410                         }
 411
 412                         CurrentDir(cd);
 413                     }
 414                     break;
 415             }
 416         }
 417     }
 418     else
 419     {
 420         SetIoErr(ERROR_NO_FREE_STORE);
 421     }
 422
 423     return buffer;
 424 }
 425
 426 BOOL __CLI_LaunchProgram
 427 (
 428     CONST_STRPTR command, struct TagItem *tags,
 429     struct WorkbenchBase *WorkbenchBase
 430 )
 431 {
 432     BPTR   input       = NULL;
 433     STRPTR commandline = NULL;
 434     IPTR                stacksize = WorkbenchBase->wb_DefaultStackSize;
 435     struct TagItem      *foundTag = NULL;
 436
 437     input = Open("CON:////Output Window/CLOSE/AUTO/WAIT", MODE_OLDFILE);
 438     if (input == NULL) goto error;
 439
 440     commandline = CLI_BuildCommandLine(command, tags);
 441     if (commandline == NULL) goto error;
 442
 443     if ((tags) && ((foundTag = FindTagItem(NP_StackSize, tags)) != NULL))
 444         stacksize = foundTag->ti_Data;
 445
 446     if
 447     (
 448         /*
 449             Launch the program. Note that there is no advantage of doing this
 450             in the handler, since we need to wait for the return value anyway
 451             (and thus we cannot cut down the blocking time by returning before
 452             the program is loaded from disk).
 453         */
 454
 455         SystemTags
 456         (
 457             commandline,
 458             SYS_Asynch,          TRUE,
 459             SYS_Input,    (IPTR) input,
 460             SYS_Output,   (IPTR) NULL,
 461             SYS_Error,    (IPTR) NULL,
 462             NP_StackSize,        stacksize,
 463             TAG_DONE
 464         ) == -1
 465     )
 466     {
 467         goto error;
 468     }
 469     FreeVec(commandline);
 470
 471     return TRUE;
 472
 473 error:
 474     if (input != NULL) Close(input);
 475     if (commandline != NULL) FreeVec(commandline);
 476
 477     return FALSE;
 478 }
 479
 480 BOOL __WB_BuildArguments
 481 (
 482     struct WBStartup *startup, BPTR lock, CONST_STRPTR name, struct TagItem *tags,
 483     struct WorkbenchBase *WorkbenchBase
 484 )
 485 {
 486     const struct TagItem *tstate   = tags,
 487                    *tag      = NULL;
 488     BPTR            lastLock = NULL;
 489     struct WBArg   *args     = NULL;
 490
 491     /*-- Calculate the number of arguments ---------------------------------*/
 492     startup->sm_NumArgs = 1;
 493     while ((tag = NextTagItem(&tstate)) != NULL)
 494     {
 495         switch (tag->ti_Tag)
 496         {
 497             case WBOPENA_ArgLock:
 498                 lastLock = (BPTR) tag->ti_Data;
 499                 break;
 500
 501             case WBOPENA_ArgName:
 502                 /*
 503                     Filter out args where both lock AND name are NULL, since
 504                     they are completely worthless to the application.
 505                 */
 506                 if (lastLock != NULL || (STRPTR) tag->ti_Data != NULL)
 507                 {
 508                     startup->sm_NumArgs++;
 509                 }
 510                 break;
 511         }
 512     }
 513
 514     /*-- Allocate memory for the arguments ---------------------------------*/
 515     args = AllocMem(sizeof(struct WBArg) * startup->sm_NumArgs, MEMF_ANY | MEMF_CLEAR);
 516     if (args != NULL)
 517     {
 518         LONG i = 0;
 519
 520         startup->sm_ArgList = args;
 521
 522         /*-- Build the argument list ---------------------------------------*/
 523         if
 524         (
 525                (args[i].wa_Lock = DupLock(lock)) == NULL
 526             || (args[i].wa_Name = StrDup(name))  == NULL
 527         )
 528         {
 529             goto error;
 530         }
 531         i++;
 532
 533         tstate = tags; lastLock = NULL;
 534         while ((tag = NextTagItem(&tstate)) != NULL)
 535         {
 536             switch (tag->ti_Tag)
 537             {
 538                 case WBOPENA_ArgLock:
 539                     lastLock = (BPTR) tag->ti_Data;
 540                     break;
 541
 542                 case WBOPENA_ArgName:
 543                     /*
 544                         Filter out args where both lock AND name are NULL,
 545                         since they are completely worthless to the application.
 546                     */
 547                     if (lastLock != NULL || (STRPTR) tag->ti_Data != NULL)
 548                     {
 549                         STRPTR name = (STRPTR) tag->ti_Data;
 550
 551                         /* Duplicate the lock */
 552                         if (lastLock != NULL)
 553                         {
 554                             args[i].wa_Lock = DupLock(lastLock);
 555
 556                             if (args[i].wa_Lock == NULL)
 557                             {
 558                                 D(bug("[WBLIB] WB_BuildArguments: Failed to duplicate lock!\n"));
 559                                 goto error;
 560                                 break;
 561                             }
 562                         }
 563                         else
 564                         {
 565                             args[i].wa_Lock = NULL;
 566                         }
 567
 568                         /* Duplicate the name */
 569                         if (name != NULL)
 570                         {
 571                             args[i].wa_Name = StrDup(name);
 572
 573                             if (args[i].wa_Name == NULL)
 574                             {
 575                                 D(bug("[WBLIB] WB_BuildArguments: Failed to duplicate string!\n"));
 576                                 goto error;
 577                                 break;
 578                             }
 579                         }
 580                         else
 581                         {
 582                             args[i].wa_Name = NULL;
 583                         }
 584
 585                         i++;
 586                     }
 587                     break;
 588             }
 589         }
 590
 591         return TRUE;
 592     }
 593     else
 594     {
 595         D(bug("[WBLIB] WB_BuildArguments: Failed to allocate memory for argument array\n"));
 596     }
 597
 598 error:
 599     D(bug("[WBLIB] WB_BuildArguments: Freeing resources after error...\n"));
 600     /* Free allocated resources */
 601     if (args != NULL)
 602     {
 603         int i;
 604
 605         for (i = 0; i < startup->sm_NumArgs; i++)
 606         {
 607             if (args[i].wa_Lock != NULL) UnLock(args[i].wa_Lock);
 608             if (args[i].wa_Name != NULL) FreeVec(args[i].wa_Name);
 609         }
 610
 611         FreeMem(args, sizeof(struct WBArg) * startup->sm_NumArgs);
 612     }
 613
 614     startup->sm_NumArgs = 0;
 615     startup->sm_ArgList = NULL;
 616
 617     return FALSE;
 618 }
 619
 620 BOOL __WB_LaunchProgram
 621 (
 622     BPTR lock, CONST_STRPTR name, struct TagItem *tags,
 623     struct WorkbenchBase *WorkbenchBase
 624 )
 625 {
 626     struct WBStartup        *startup = NULL;
 627     struct WBCommandMessage *message = NULL;
 628     struct TagItem          *foundTag = NULL;
 629
 630     /*-- Allocate memory for messages --------------------------------------*/
 631     startup = CreateWBS();
 632     if (startup == NULL)
 633     {
 634         D(bug("[WBLIB] WB_LaunchProgram: Failed to allocate memory for startup message\n"));
 635         SetIoErr(ERROR_NO_FREE_STORE);
 636         goto error;
 637     }
 638
 639     message = CreateWBCM(WBCM_TYPE_LAUNCH);
 640     if (message == NULL)
 641     {
 642         D(bug("[WBLIB] WB_LaunchProgram: Failed to allocate memory for launch message\n"));
 643         SetIoErr(ERROR_NO_FREE_STORE);
 644         goto error;
 645     }
 646
 647     if ((tags) && ((foundTag = FindTagItem(NP_StackSize, tags)) != NULL))
 648     {
 649         message->wbcm_Tags =  AllocateTagItems(2);
 650         message->wbcm_Tags[0].ti_Tag = foundTag->ti_Tag;
 651         message->wbcm_Tags[0].ti_Data = foundTag->ti_Data;
 652         message->wbcm_Tags[1].ti_Tag = TAG_DONE;
 653     }
 654
 655     /*-- Build the arguments array -----------------------------------------*/
 656     if (!WB_BuildArguments(startup, lock, name, tags))
 657     {
 658         D(bug("[WBLIB] WB_LaunchProgram: Failed to build arguments\n"));
 659         goto error;
 660     }
 661
 662     /*-- Send message to handler -------------------------------------------*/
 663     /* NOTE: The handler will deallocate all resources of this message! */
 664     message->wbcm_Data.Launch.Startup = startup;
 665
 666     PutMsg(&(WorkbenchBase->wb_HandlerPort), (struct Message *) message);
 667
 668     D(bug("[WBLIB]  WB_LaunchProgram: Success\n"));
 669
 670     return TRUE;
 671
 672 error:
 673     if (startup != NULL) DestroyWBS(startup);
 674     if (message != NULL) DestroyWBCM(message);
 675
 676     D(bug("[WBLIB] WB_LaunchProgram: Failure\n"));
 677
 678     return FALSE;
 679 }