test/misc/hostcb.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Tool to access host clipboard, when using a hosted version of AROS.
   6 */
   7
   8
   9 #include <dos/dos.h>
  10 #include <libraries/iffparse.h>
  11 #include <datatypes/textclass.h>
  12 #include <proto/exec.h>
  13 #include <proto/dos.h>
  14 #include <proto/iffparse.h>
  15 #include <aros/debug.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19
  20 /****************************************************************************************/
  21
  22 #define ARG_TEMPLATE        "TOSTDOUT=OUT/S,TOAROSCLIP=TOAROS/S,TOFILE=TO/K,"   \
  23                             "FROMAROSCLIP=FROMAROS/S,FROMSTRING=STRING/K,"      \
  24                             "FROMFILE=FROM/K,AROSCLIPUNIT=AROSUNIT/N/K,QUIET/S"
  25
  26 #define ARG_TOSTDOUT        0
  27 #define ARG_TOAROSCLIP      1
  28 #define ARG_TOFILE          2
  29 #define ARG_FROMAROSCLIP    3
  30 #define ARG_FROMSTRING      4
  31 #define ARG_FROMFILE        5
  32 #define ARG_AROSCLIPUNIT    6
  33 #define ARG_QUIET           7
  34 #define NUM_ARGS            8
  35
  36 #define CMD(msg)        ((msg)->mn_Node.ln_Pri)
  37 #define PARAM(msg)      ((msg)->mn_Node.ln_Name)
  38 #define RETVAL(msg)     ((msg)->mn_Node.ln_Name)
  39 #define SUCCESS(msg)    ((msg)->mn_Node.ln_Pri)
  40
  41 /****************************************************************************************/
  42
  43 struct Library  *IFFParseBase;
  44 struct MsgPort  *replyport;
  45 struct Message   msg;
  46 struct RDArgs   *myargs;
  47 BPTR             fh;
  48 ULONG            arosclipunit;
  49 STRPTR           filebuffer, hostbuffer;
  50 IPTR             args[NUM_ARGS];
  51 UBYTE            s[256];
  52
  53 /****************************************************************************************/
  54
  55 static void cleanup(char *msg, ULONG retcode)
  56 {
  57     if (msg && !args[ARG_QUIET])
  58     {
  59         fprintf(stderr, "hostcb: %s\n", msg);
  60     }
  61
  62     if (fh) Close(fh);
  63     FreeVec(hostbuffer);
  64     FreeVec(filebuffer);
  65     if (myargs) FreeArgs(myargs);
  66
  67     if (IFFParseBase) CloseLibrary(IFFParseBase);
  68     if (replyport) DeleteMsgPort(replyport);
  69
  70     exit(retcode);
  71 }
  72
  73 /****************************************************************************************/
  74
  75 static void noport(void)
  76 {
  77     cleanup("HOST_CLIPBOARD port not found!", RETURN_ERROR);
  78 }
  79
  80 /****************************************************************************************/
  81
  82 static void cmdfailed(void)
  83 {
  84     cleanup("HOST_CLIPBOARD cmd failure!", RETURN_ERROR);
  85 }
  86
  87 /****************************************************************************************/
  88
  89 static void init(void)
  90 {
  91     replyport = CreateMsgPort();
  92     if (!replyport) cleanup("Out of memory", RETURN_ERROR);
  93
  94     msg.mn_ReplyPort = replyport;
  95
  96     IFFParseBase = OpenLibrary("iffparse.library", 36);
  97 }
  98
  99 /****************************************************************************************/
 100
 101 static void getarguments(void)
 102 {
 103     if (!(myargs = ReadArgs(ARG_TEMPLATE, args, 0)))
 104     {
 105         Fault(IoErr(), 0, s, 255);
 106         cleanup(s, RETURN_FAIL);
 107     }
 108
 109     if (args[ARG_AROSCLIPUNIT]) arosclipunit = *(IPTR *)args[ARG_AROSCLIPUNIT];
 110 }
 111
 112 /****************************************************************************************/
 113
 114 static BOOL sendclipboardmsg(struct Message *msg, char command, void *param)
 115 {
 116     struct MsgPort *port;
 117
 118     Forbid();
 119     port = FindPort("HOST_CLIPBOARD");
 120     if (port)
 121     {
 122         CMD(msg) = command;
 123         PARAM(msg) = param;
 124
 125         PutMsg(port, msg);
 126     }
 127     Permit();
 128
 129     return port ? TRUE : FALSE;
 130 }
 131
 132 /****************************************************************************************/
 133
 134 static void toarosclip(void)
 135 {
 136     struct IFFHandle *iff;
 137     BOOL              sent;
 138
 139     if (!IFFParseBase) cleanup("Failed to open iffparse.library!", RETURN_FAIL);
 140
 141     sent = sendclipboardmsg(&msg, 'R', NULL);
 142     if (sent)
 143     {
 144         WaitPort(replyport);
 145         GetMsg(replyport);
 146
 147         if (SUCCESS(&msg) && RETVAL(&msg))
 148         {
 149             BOOL ok = FALSE;
 150
 151             iff = AllocIFF();
 152             if (iff)
 153             {
 154                 if ((iff->iff_Stream = (IPTR)OpenClipboard(arosclipunit)))
 155                 {
 156                     InitIFFasClip(iff);
 157
 158                     if (!OpenIFF(iff, IFFF_WRITE))
 159                     {
 160                         if (!PushChunk(iff, ID_FTXT, ID_FORM, IFFSIZE_UNKNOWN))
 161                         {
 162                             if (!PushChunk(iff, 0, ID_CHRS, IFFSIZE_UNKNOWN))
 163                             {
 164                                 ULONG len = strlen(RETVAL(&msg));
 165
 166                                 if (WriteChunkBytes(iff, RETVAL(&msg), len) == len)
 167                                 {
 168                                     ok = TRUE;
 169                                 }
 170                                 PopChunk(iff);
 171
 172                             } /* if (!PushChunk(iff, 0, ID_CHRS, IFFSIZE_UNKNOWN)) */
 173
 174                             PopChunk(iff);
 175
 176                         } /* if (!PushChunk(iff, ID_FTXT, ID_FORM, IFFSIZE_UNKNOWN)) */
 177
 178                         CloseIFF(iff);
 179
 180                     } /* if (!OpenIFF(iff, IFFF_WRITE)) */
 181
 182                     CloseClipboard((struct ClipboardHandle*)iff->iff_Stream);
 183
 184                 } /* if ((iff->iff_Stream = (IPTR)OpenClipboard(arosclipunit))) */
 185
 186                 FreeIFF(iff);
 187
 188             } /* if (iff) */
 189
 190             FreeVec(RETVAL(&msg));
 191
 192             if (!ok) cleanup("Error writing to AROS clipboard!", RETURN_ERROR);
 193
 194         } /* if (SUCCESS(&msg) && RETVAL(&msg)) */
 195         else
 196         {
 197             cmdfailed();
 198         }
 199
 200     } /* if (sent) */
 201     else
 202     {
 203         noport();
 204     }
 205
 206 }
 207
 208 /****************************************************************************************/
 209
 210 static void fromarosclip(void)
 211 {
 212     struct IFFHandle *iff;
 213     BOOL              sent, ok = FALSE;
 214
 215     if (!IFFParseBase) cleanup("Failed to open iffparse.library!", RETURN_FAIL);
 216
 217     iff = AllocIFF();
 218     if (iff)
 219     {
 220         if ((iff->iff_Stream = (IPTR)OpenClipboard(arosclipunit)))
 221         {
 222             InitIFFasClip(iff);
 223
 224             if (!OpenIFF(iff, IFFF_READ))
 225             {
 226                 if (!StopChunk(iff, ID_FTXT, ID_CHRS))
 227                 {
 228                     ULONG filebuffer_size = 0;
 229
 230                     for(;;)
 231                     {
 232                         struct ContextNode *cn;
 233                         LONG                error;
 234
 235                         error = ParseIFF(iff, IFFPARSE_SCAN);
 236                         if ((error != 0) && (error != IFFERR_EOC)) break;
 237
 238                         cn = CurrentChunk(iff);
 239                         if (!cn)
 240                         {
 241                             kprintf(" [ZERO CONTEXTNODE]\n\n");
 242                             continue;
 243                         }
 244
 245                         if ((cn->cn_Type == ID_FTXT) && (cn->cn_ID == ID_CHRS))
 246                         {
 247                             if (!filebuffer)
 248                             {
 249                                 filebuffer = AllocVec(cn->cn_Size + 1, MEMF_ANY);
 250                                 if (!filebuffer) break;
 251
 252                                 ok = TRUE;
 253                             }
 254                             else
 255                             {
 256                                 STRPTR new_filebuffer;
 257
 258                                 new_filebuffer = AllocVec(filebuffer_size + cn->cn_Size + 1, MEMF_ANY);
 259                                 if (!new_filebuffer)
 260                                 {
 261                                     ok = FALSE;
 262                                     break;
 263                                 }
 264
 265                                 CopyMem(filebuffer, new_filebuffer, filebuffer_size);
 266                                 FreeVec(filebuffer);
 267                                 filebuffer = new_filebuffer;
 268                             }
 269
 270                             if (ReadChunkBytes(iff, filebuffer + filebuffer_size, cn->cn_Size) != cn->cn_Size)
 271                             {
 272                                 ok = FALSE;
 273                                 break;
 274                             }
 275
 276                             filebuffer_size += cn->cn_Size;
 277                             filebuffer[filebuffer_size] = '\0';
 278
 279                         } /* if ((cn->cn_Type == ID_FTXT) && (cn->cn_ID == ID_CHRS)) */
 280
 281                     } /* for(;;) */
 282
 283                 } /* if (!StopChunk(iff, ID_FTXT, ID_CHRS)) */
 284
 285                 CloseIFF(iff);
 286
 287             } /* if (!OpenIFF(iff, IFFF_READ)) */
 288
 289             CloseClipboard((struct ClipboardHandle*)iff->iff_Stream);
 290
 291         } /* if ((iff->iff_Stream = (IPTR)OpenClipboard(arosclipunit))) */
 292         FreeIFF(iff);
 293
 294     } /* if (iff) */
 295
 296     if (!ok)
 297     {
 298         cleanup("Error reading from AROS clipboard!", RETURN_ERROR);
 299     }
 300
 301     sent = sendclipboardmsg(&msg, 'W', filebuffer);
 302     if (sent)
 303     {
 304         WaitPort(replyport);
 305         GetMsg(replyport);
 306
 307         if (SUCCESS(&msg))
 308         {
 309             FreeVec(filebuffer),
 310             filebuffer = 0;
 311         }
 312         else
 313         {
 314             cmdfailed();
 315         }
 316     }
 317     else
 318     {
 319         noport();
 320     }
 321
 322 }
 323
 324 /****************************************************************************************/
 325
 326 static void tostdout(void)
 327 {
 328     BOOL sent;
 329
 330     sent = sendclipboardmsg(&msg, 'R', NULL);
 331     if (sent)
 332     {
 333         WaitPort(replyport);
 334         GetMsg(replyport);
 335
 336         if (SUCCESS(&msg) && RETVAL(&msg))
 337         {
 338             printf("%s", RETVAL(&msg));
 339             FreeVec(RETVAL(&msg));
 340         }
 341         else
 342         {
 343             cmdfailed();
 344         }
 345     }
 346     else
 347     {
 348         noport();
 349     }
 350
 351 }
 352
 353 /****************************************************************************************/
 354
 355 static void tofile(char *filename)
 356 {
 357     BOOL sent;
 358
 359     sent = sendclipboardmsg(&msg, 'R', NULL);
 360     if (sent)
 361     {
 362         WaitPort(replyport);
 363         GetMsg(replyport);
 364
 365         if (SUCCESS(&msg) && RETVAL(&msg))
 366         {
 367             ULONG len;
 368
 369             hostbuffer = RETVAL(&msg);
 370             len = strlen(hostbuffer);
 371
 372             fh = Open(filename, MODE_NEWFILE);
 373             if (!fh)
 374             {
 375                 Fault(IoErr(), 0, s, 255);
 376                 cleanup(s, RETURN_ERROR);
 377             }
 378
 379             if (Write(fh, hostbuffer, len) != len)
 380             {
 381                 Fault(IoErr(), 0, s, 255);
 382                 cleanup(s, RETURN_ERROR);
 383             }
 384
 385             Close(fh);
 386             fh = 0;
 387
 388             FreeVec(hostbuffer);
 389             hostbuffer = 0;
 390         }
 391         else
 392         {
 393             cmdfailed();
 394         }
 395     }
 396     else
 397     {
 398         noport();
 399     }
 400
 401 }
 402
 403 /****************************************************************************************/
 404
 405 static void fromstring(char *s)
 406 {
 407     BOOL sent;
 408
 409     sent = sendclipboardmsg(&msg, 'W', s);
 410     if (sent)
 411     {
 412         WaitPort(replyport);
 413         GetMsg(replyport);
 414
 415         if (!SUCCESS(&msg))
 416         {
 417             cmdfailed();
 418         }
 419     }
 420     else
 421     {
 422         noport();
 423     }
 424
 425 }
 426
 427 /****************************************************************************************/
 428
 429 static void fromfile(char *filename)
 430 {
 431     BOOL sent;
 432     LONG len;
 433
 434     fh = Open(filename, MODE_OLDFILE);
 435     if (!fh)
 436     {
 437         Fault(IoErr(), 0, s, 255);
 438         cleanup(s, RETURN_ERROR);
 439     }
 440
 441     len = Seek(fh, 0, OFFSET_END);
 442     if (len != -1) len = Seek(fh, 0, OFFSET_BEGINNING);
 443
 444     if (len == -1)
 445     {
 446         Fault(IoErr(), 0, s, 255);
 447         cleanup(s, RETURN_ERROR);
 448     }
 449
 450     filebuffer = AllocVec(len + 1, MEMF_ANY);
 451     if (!filebuffer)
 452     {
 453         cleanup("Out of memory!", RETURN_ERROR);
 454     }
 455
 456     if (Read(fh, filebuffer, len) != len)
 457     {
 458         Fault(IoErr(), 0, s, 255);
 459         cleanup(s, RETURN_ERROR);
 460     }
 461
 462     Close(fh);
 463     fh = 0;
 464
 465     filebuffer[len] = '\0';
 466
 467     sent = sendclipboardmsg(&msg, 'W', filebuffer);
 468     if (sent)
 469     {
 470         WaitPort(replyport);
 471         GetMsg(replyport);
 472
 473         if (!SUCCESS(&msg))
 474         {
 475             cmdfailed();
 476         }
 477     }
 478     else
 479     {
 480         noport();
 481     }
 482
 483     FreeVec(filebuffer);
 484     filebuffer = 0;
 485
 486 }
 487
 488 /****************************************************************************************/
 489
 490 int main(void)
 491 {
 492     init();
 493     getarguments();
 494     if (args[ARG_TOAROSCLIP]) toarosclip();
 495     if (args[ARG_FROMAROSCLIP]) fromarosclip();
 496     if (args[ARG_TOSTDOUT]) tostdout();
 497     if (args[ARG_TOFILE]) tofile((char *)args[ARG_TOFILE]);
 498     if (args[ARG_FROMSTRING]) fromstring((char *)args[ARG_FROMSTRING]);
 499     if (args[ARG_FROMFILE]) fromfile((char *)args[ARG_FROMFILE]);
 500
 501     cleanup(0, RETURN_OK);
 502
 503     return 0;
 504 }
 505
 506 /****************************************************************************************/