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("OpenWorkbenchObject: name = %s\n", name));
  88     D(bug("OpenWorkbenchObject: 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("OpenWorkbenchObject: 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("OpenWorkbenchObject: 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("OpenWorkbenchObject: it's a WB program\n"));
 150
 151                     if (lock != NULL)
 152                     {
 153                         BPTR parent = ParentDir(lock);
 154
 155                         if (parent != NULL)
 156                         {
 157                             success = WB_LaunchProgram
 158                             (
 159                                 parent, FilePart(name), tags
 160                             );
 161
 162                             if (!success)
 163                             {
 164                                 /*
 165                                     Fallback to launching it as a CLI program.
 166                                     Most likely it will also fail, but we
 167                                     might get lucky.
 168                                 */
 169                                 success = CLI_LaunchProgram(name, tags);
 170                             }
 171
 172                             UnLock(parent);
 173                         }
 174
 175                         UnLock(lock);
 176                     }
 177                 }
 178                 else
 179                 {
 180                     /* It's a CLI program */
 181
 182                     D(bug("OpenWorkbenchObject: it's a CLI program\n"));
 183
 184                     success = CLI_LaunchProgram(name, tags);
 185                 }
 186                 break;
 187
 188             case WBPROJECT:
 189                 /* It's a project; try to launch it via its default tool. */
 190
 191                 D(bug("OpenWorkbenchObject: it's a PROJECT\n"));
 192                 D(bug("OpenWorkbenchObject: default tool: %s\n", icon->do_DefaultTool));
 193
 194                 if
 195                 (
 196                        icon->do_DefaultTool != NULL
 197                     && strlen(icon->do_DefaultTool) > 0
 198                 )
 199                 {
 200                     BPTR lock = (BPTR)NULL, parent = (BPTR)NULL;
 201
 202                     lock = Lock(name, ACCESS_READ);
 203                     if (lock != (BPTR)NULL)
 204                         parent = ParentDir(lock);
 205                     if (parent != (BPTR)NULL)
 206                     {
 207                         struct TagItem tags[] =
 208                         {
 209                             {WBOPENA_ArgLock, (IPTR) parent},
 210                             {WBOPENA_ArgName, (IPTR) FilePart(name)},
 211                             {TAG_DONE, (IPTR)NULL}
 212                         };
 213
 214                         if (FindToolType(icon->do_ToolTypes, "CLI") == NULL)
 215                         {
 216                             BPTR lock2 = (BPTR)NULL, parent2 = (BPTR)NULL;
 217
 218                             lock2 = Lock(icon->do_DefaultTool, ACCESS_READ);
 219                             if (lock2 != (BPTR)NULL)
 220                                 parent2 = ParentDir(lock2);
 221                             if (parent2 != NULL)
 222                             {
 223                                 success = WB_LaunchProgram
 224                                 (
 225                                     parent2, FilePart(icon->do_DefaultTool), tags
 226                                 );
 227                             }
 228                             UnLock(parent2);
 229                             UnLock(lock2);
 230                         }
 231                         else
 232                         {
 233                             success = CLI_LaunchProgram
 234                             (
 235                                 icon->do_DefaultTool, tags
 236                             );
 237                         }
 238
 239                         UnLock(parent);
 240                         UnLock(lock);
 241                     }
 242                 }
 243
 244                 if (!success)
 245                 {
 246                     // FIXME: open execute command?
 247                 }
 248                 break;
 249         }
 250
 251         FreeDiskObject(icon);
 252     }
 253     else
 254     {
 255         /*
 256             Getting (a possibly default) icon for the path failed, and
 257             therefore there is no such file. We need to search the default
 258             search path for an executable of that name and launch it. This
 259             only makes sense if the name is *not* an (absolute or relative)
 260             path: that is, it must not contain any ':' or '/'.
 261         */
 262
 263         if (strpbrk(name, "/:") == NULL)
 264         {
 265             struct CommandLineInterface *cli = Cli();
 266             if (cli != NULL)
 267             {
 268                 BPTR *paths;          /* Path list */
 269                 BOOL  running = TRUE;
 270
 271                 /* Iterate over all paths in the path list */
 272                 for
 273                 (
 274                     paths = (BPTR *) BADDR(cli->cli_CommandDir);
 275                     running == TRUE && paths != NULL;
 276                     paths = (BPTR *) BADDR(paths[0]) /* next path */
 277                 )
 278                 {
 279                     BPTR cd   = CurrentDir(paths[1]);
 280                     BPTR lock = Lock(name, SHARED_LOCK);
 281
 282                     if (lock != NULL)
 283                     {
 284                         success = OpenWorkbenchObjectA(name, tags);
 285                         running = FALSE;
 286
 287                         UnLock(lock);
 288                     }
 289
 290                     CurrentDir(cd);
 291                 }
 292             }
 293         }
 294     }
 295
 296     D(bug("OpenWorkbenchObject: success = %d\n", success));
 297
 298     return success;
 299
 300     AROS_LIBFUNC_EXIT
 301 } /* OpenWorkbenchObjectA() */
 302
 303 STRPTR __CLI_BuildCommandLine
 304 (
 305     CONST_STRPTR command, struct TagItem *tags,
 306     struct WorkbenchBase *WorkbenchBase
 307 )
 308 {
 309     const struct TagItem *tstate   = tags;
 310     const struct TagItem *tag      = NULL;
 311     BPTR            lastLock = NULL;
 312     STRPTR          buffer   = NULL;
 313     ULONG           length   = strlen(command) + 3 /* NULL + 2 '"' */;
 314
 315     /*-- Calculate length of resulting string ------------------------------*/
 316     while ((tag = NextTagItem(&tstate)) != NULL)
 317     {
 318         switch (tag->ti_Tag)
 319         {
 320             case WBOPENA_ArgLock:
 321                 lastLock = (BPTR) tag->ti_Data;
 322                 break;
 323
 324             case WBOPENA_ArgName:
 325                 if (lastLock != NULL)
 326                 {
 327                     BPTR cd   = CurrentDir(lastLock);
 328                     BPTR lock = Lock((STRPTR) tag->ti_Data, ACCESS_READ);
 329                     if (lock != NULL)
 330                     {
 331                         STRPTR path = AllocateNameFromLock(lock);
 332                         if (path != NULL)
 333                         {
 334                             length += 3 /* space + 2 '"' */ + strlen(path);
 335                             FreeVec(path);
 336                         }
 337
 338                         UnLock(lock);
 339                     }
 340
 341                     CurrentDir(cd);
 342                 }
 343                 break;
 344         }
 345     }
 346
 347     /*-- Allocate space for command line string ----------------------------*/
 348     buffer = AllocVec(length, MEMF_ANY);
 349
 350     if (buffer != NULL)
 351     {
 352         buffer[0] = '\0';
 353
 354         /*-- Build command line --------------------------------------------*/
 355         strcat(buffer, "\"");
 356         strcat(buffer, command);
 357         strcat(buffer, "\"");
 358
 359         tstate = tags; lastLock = NULL;
 360         while ((tag = NextTagItem(&tstate)) != NULL )
 361         {
 362             switch (tag->ti_Tag)
 363             {
 364                 case WBOPENA_ArgLock:
 365                     lastLock = (BPTR) tag->ti_Data;
 366                     break;
 367
 368                 case WBOPENA_ArgName:
 369                     if (lastLock != NULL)
 370                     {
 371                         BPTR cd   = CurrentDir(lastLock);
 372                         BPTR lock = Lock((STRPTR) tag->ti_Data, ACCESS_READ);
 373                         if (lock != NULL)
 374                         {
 375                             STRPTR path = AllocateNameFromLock(lock);
 376                             if (path != NULL)
 377                             {
 378                                 strcat(buffer, " \"");
 379                                 strcat(buffer, path);
 380                                 strcat(buffer, "\"");
 381                                 FreeVec(path);
 382                             }
 383
 384                             UnLock(lock);
 385                         }
 386
 387                         CurrentDir(cd);
 388                     }
 389                     break;
 390             }
 391         }
 392     }
 393     else
 394     {
 395         SetIoErr(ERROR_NO_FREE_STORE);
 396     }
 397
 398     return buffer;
 399 }
 400
 401 BOOL __CLI_LaunchProgram
 402 (
 403     CONST_STRPTR command, struct TagItem *tags,
 404     struct WorkbenchBase *WorkbenchBase
 405 )
 406 {
 407     BPTR   input       = NULL;
 408     STRPTR commandline = NULL;
 409
 410     input = Open("CON:////Output Window/CLOSE/AUTO/WAIT", MODE_OLDFILE);
 411     if (input == NULL) goto error;
 412
 413     commandline = CLI_BuildCommandLine(command, tags);
 414     if (commandline == NULL) goto error;
 415
 416     if
 417     (
 418         /*
 419             Launch the program. Note that there is no advantage of doing this
 420             in the handler, since we need to wait for the return value anyway
 421             (and thus we cannot cut down the blocking time by returning before
 422             the program is loaded from disk).
 423         */
 424
 425         SystemTags
 426         (
 427             commandline,
 428             SYS_Asynch,          TRUE,
 429             SYS_Input,    (IPTR) input,
 430             SYS_Output,   (IPTR) NULL,
 431             SYS_Error,    (IPTR) NULL,
 432             NP_StackSize,        WorkbenchBase->wb_DefaultStackSize,
 433             TAG_DONE
 434         ) == -1
 435     )
 436     {
 437         goto error;
 438     }
 439     FreeVec(commandline);
 440
 441     return TRUE;
 442
 443 error:
 444     if (input != NULL) Close(input);
 445     if (commandline != NULL) FreeVec(commandline);
 446
 447     return FALSE;
 448 }
 449
 450 BOOL __WB_BuildArguments
 451 (
 452     struct WBStartup *startup, BPTR lock, CONST_STRPTR name, struct TagItem *tags,
 453     struct WorkbenchBase *WorkbenchBase
 454 )
 455 {
 456     const struct TagItem *tstate   = tags,
 457                    *tag      = NULL;
 458     BPTR            lastLock = NULL;
 459     struct WBArg   *args     = NULL;
 460
 461     /*-- Calculate the number of arguments ---------------------------------*/
 462     startup->sm_NumArgs = 1;
 463     while ((tag = NextTagItem(&tstate)) != NULL)
 464     {
 465         switch (tag->ti_Tag)
 466         {
 467             case WBOPENA_ArgLock:
 468                 lastLock = (BPTR) tag->ti_Data;
 469                 break;
 470
 471             case WBOPENA_ArgName:
 472                 /*
 473                     Filter out args where both lock AND name are NULL, since
 474                     they are completely worthless to the application.
 475                 */
 476                 if (lastLock != NULL || (STRPTR) tag->ti_Data != NULL)
 477                 {
 478                     startup->sm_NumArgs++;
 479                 }
 480                 break;
 481         }
 482     }
 483
 484     /*-- Allocate memory for the arguments ---------------------------------*/
 485     args = AllocMem(sizeof(struct WBArg) * startup->sm_NumArgs, MEMF_ANY | MEMF_CLEAR);
 486     if (args != NULL)
 487     {
 488         LONG i = 0;
 489
 490         startup->sm_ArgList = args;
 491
 492         /*-- Build the argument list ---------------------------------------*/
 493         if
 494         (
 495                (args[i].wa_Lock = DupLock(lock)) == NULL
 496             || (args[i].wa_Name = StrDup(name))  == NULL
 497         )
 498         {
 499             goto error;
 500         }
 501         i++;
 502
 503         tstate = tags; lastLock = NULL;
 504         while ((tag = NextTagItem(&tstate)) != NULL)
 505         {
 506             switch (tag->ti_Tag)
 507             {
 508                 case WBOPENA_ArgLock:
 509                     lastLock = (BPTR) tag->ti_Data;
 510                     break;
 511
 512                 case WBOPENA_ArgName:
 513                     /*
 514                         Filter out args where both lock AND name are NULL,
 515                         since they are completely worthless to the application.
 516                     */
 517                     if (lastLock != NULL || (STRPTR) tag->ti_Data != NULL)
 518                     {
 519                         STRPTR name = (STRPTR) tag->ti_Data;
 520
 521                         /* Duplicate the lock */
 522                         if (lastLock != NULL)
 523                         {
 524                             args[i].wa_Lock = DupLock(lastLock);
 525
 526                             if (args[i].wa_Lock == NULL)
 527                             {
 528                                 D(bug("workbench.library: WB_BuildArguments: Failed to duplicate lock!\n"));
 529                                 goto error;
 530                                 break;
 531                             }
 532                         }
 533                         else
 534                         {
 535                             args[i].wa_Lock = NULL;
 536                         }
 537
 538                         /* Duplicate the name */
 539                         if (name != NULL)
 540                         {
 541                             args[i].wa_Name = StrDup(name);
 542
 543                             if (args[i].wa_Name == NULL)
 544                             {
 545                                 D(bug("workbench.library: WB_BuildArguments: Failed to duplicate string!\n"));
 546                                 goto error;
 547                                 break;
 548                             }
 549                         }
 550                         else
 551                         {
 552                             args[i].wa_Name = NULL;
 553                         }
 554
 555                         i++;
 556                     }
 557                     break;
 558             }
 559         }
 560
 561         return TRUE;
 562     }
 563     else
 564     {
 565         D(bug("workbench.library: WB_BuildArguments: Failed to allocate memory for argument array\n"));
 566     }
 567
 568 error:
 569     D(bug("workbench.library: WB_BuildArguments: Freeing resources after error...\n"));
 570     /* Free allocated resources */
 571     if (args != NULL)
 572     {
 573         int i;
 574
 575         for (i = 0; i < startup->sm_NumArgs; i++)
 576         {
 577             if (args[i].wa_Lock != NULL) UnLock(args[i].wa_Lock);
 578             if (args[i].wa_Name != NULL) FreeVec(args[i].wa_Name);
 579         }
 580
 581         FreeMem(args, sizeof(struct WBArg) * startup->sm_NumArgs);
 582     }
 583
 584     startup->sm_NumArgs = 0;
 585     startup->sm_ArgList = NULL;
 586
 587     return FALSE;
 588 }
 589
 590 BOOL __WB_LaunchProgram
 591 (
 592     BPTR lock, CONST_STRPTR name, struct TagItem *tags,
 593     struct WorkbenchBase *WorkbenchBase
 594 )
 595 {
 596     struct WBStartup        *startup = NULL;
 597     struct WBCommandMessage *message = NULL;
 598
 599     /*-- Allocate memory for messages --------------------------------------*/
 600     startup = CreateWBS();
 601     if (startup == NULL)
 602     {
 603         D(bug("workbench.library: WB_LaunchProgram: Failed to allocate memory for startup message\n"));
 604         SetIoErr(ERROR_NO_FREE_STORE);
 605         goto error;
 606     }
 607
 608     message = CreateWBCM(WBCM_TYPE_LAUNCH);
 609     if (message == NULL)
 610     {
 611         D(bug("workbench.library: WB_LaunchProgram: Failed to allocate memory for launch message\n"));
 612         SetIoErr(ERROR_NO_FREE_STORE);
 613         goto error;
 614     }
 615
 616     /*-- Build the arguments array -----------------------------------------*/
 617     if (!WB_BuildArguments(startup, lock, name, tags))
 618     {
 619         D(bug("workbench.library: WB_LaunchProgram: Failed to build arguments\n"));
 620         goto error;
 621     }
 622
 623     /*-- Send message to handler -------------------------------------------*/
 624     /* NOTE: The handler will deallocate all resources of this message! */
 625     message->wbcm_Data.Launch.Startup = startup;
 626
 627     PutMsg(&(WorkbenchBase->wb_HandlerPort), (struct Message *) message);
 628
 629     D(bug("workbench.library: WB_LaunchProgram: Success\n"));
 630
 631     return TRUE;
 632
 633 error:
 634     if (startup != NULL) DestroyWBS(startup);
 635     if (message != NULL) DestroyWBCM(message);
 636
 637     D(bug("workbench.library: WB_LaunchProgram: Failure\n"));
 638
 639     return FALSE;
 640 }