cde/lib/csa/convert3-4.c

   1 /* $XConsortium: convert3-4.c /main/1 1996/04/21 19:22:31 drk $ */
   2 /*
   3  *  (c) Copyright 1993, 1994 Hewlett-Packard Company
   4  *  (c) Copyright 1993, 1994 International Business Machines Corp.
   5  *  (c) Copyright 1993, 1994 Novell, Inc.
   6  *  (c) Copyright 1993, 1994 Sun Microsystems, Inc.
   7  */
   8
   9 #include <EUSCompat.h>
  10 #include <malloc.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include "rtable3.h"
  14 #include "rtable4.h"
  15 #include "convert3-4.h"
  16
  17 /*
  18  * forward declaration of static functions
  19  */
  20 static void assign_period3to4(Period_3 *p3, Period_4 *p4);
  21 static void assign_tag3to4(Tag_3 *t3, Tag_4 *t4);
  22 static void assign_privacy3to4(Privacy_Level_3 *p3, Privacy_Level_4 *p4);
  23 static void assign_status3to4(Appt_Status_3 *s3, Appt_Status_4 *s4);
  24 static Buffer_4 buffer3_to_buffer4(Buffer_3 b);
  25 static void period3_to_period4(Period_3 *p3, Period_4 *p4);
  26 static Tag_4 * tag3_to_tag4(Tag_3 *t3);
  27 static Attribute_4 * attr3_to_attr4(Attribute_3 *a3);
  28 static Except_4 * except3_to_except4(Except_3 *e3);
  29 static void id3_to_id4(Id_3 *from, Id_4 *to);
  30 static Uid_4 * uid3_to_uid4(Uid_3 *ui3);
  31 static Appt_4 * appt3_to_appt4(Appt_3 *a3);
  32 static Abb_Appt_4 * abb3_to_abb4(Abb_Appt_3 *a3);
  33 static void apptid3_to_apptid4(Apptid_3 *from, Apptid_4 *to);
  34 static Reminder_4 * reminder3_to_reminder4(Reminder_3 *r3);
  35 static Table_Res_Type_4 tablerestype3_to_tablerestype4(Table_Res_Type_3 t);
  36 static void tablereslist3_to_tablereslist4(Table_Res_List_3 *from,
  37                 Table_Res_List_4 *to);
  38 static Access_Entry_4 * acclist3_to_acclist4(Access_Entry_3 *l3);
  39 static Range_4 * range3_to_range4(Range_3 *r3);
  40 static Keyrange_4 * keyrange3_to_keyrange4(Keyrange_3 *r3);
  41 static Table_Args_Type_4 argstag3_to_argstag4(Table_Args_Type_3 t);
  42 static void args3_to_args4(Args_3 *from, Args_4 *to);
  43 static Uidopt_4 * uid3_to_uidopt(Uid_3 *uid3, Options_4 opt);
  44
  45 /**************** DATA TYPE (3->4) CONVERSION ROUTINES **************/
  46
  47 extern Access_Status_4
  48 _DtCm_accstat3_to_accstat4(Access_Status_3 s)
  49 {
  50         switch (s) {
  51         case access_ok_3:
  52                 return(access_ok_4);
  53         case access_added_3:
  54                 return(access_added_4);
  55         case access_removed_3:
  56                 return(access_removed_4);
  57         case access_failed_3:
  58                 return(access_failed_4);
  59         case access_exists_3:
  60                 return(access_exists_4);
  61         case access_partial_3:
  62                 return(access_partial_4);
  63         case access_other_3:
  64         default:
  65                 return(access_other_4);
  66         }
  67 }
  68
  69 extern Table_Res_4 *
  70 _DtCm_tableres3_to_tableres4(Table_Res_3 *r3)
  71 {
  72         Table_Res_4 *r4;
  73
  74         if (r3==NULL) return((Table_Res_4 *)NULL);
  75         r4 = (Table_Res_4 *)calloc(1, sizeof(Table_Res_4));
  76         r4->status = _DtCm_accstat3_to_accstat4(r3->status);
  77         tablereslist3_to_tablereslist4(&(r3->res), &(r4->res));
  78         return(r4);
  79 }
  80
  81 extern Access_Args_4 *
  82 _DtCm_accargs3_to_accargs4(Access_Args_3 *a3)
  83 {
  84         Access_Args_4 *a4;
  85
  86         if (a3==NULL) return((Access_Args_4 *)NULL);
  87         a4 = (Access_Args_4 *)calloc(1, sizeof(Access_Args_4));
  88         a4->target = buffer3_to_buffer4(a3->target);
  89         a4->access_list = acclist3_to_acclist4(a3->access_list);
  90         return(a4);
  91 }
  92
  93 extern Table_Args_4 *
  94 _DtCm_tableargs3_to_tableargs4(Table_Args_3 *a3)
  95 {
  96         Table_Args_4 *a4;
  97
  98         if (a3==NULL) return((Table_Args_4 *)NULL);
  99         a4 = (Table_Args_4 *)calloc(1, sizeof(Table_Args_4));
 100         a4->target = buffer3_to_buffer4(a3->target);
 101         args3_to_args4(&(a3->args), &(a4->args));
 102         a4->pid = a3->pid;
 103         return(a4);
 104 }
 105
 106 extern Table_Args_4 *
 107 _DtCm_tabledelargs3_to_tabledelargs4(Table_Args_3 *a3, Options_4 opt)
 108 {
 109         Table_Args_4 *a4;
 110
 111         if (a3 == NULL)
 112                 return((Table_Args_4 *)NULL);
 113
 114         a4 = (Table_Args_4 *)calloc(1, sizeof(Table_Args_4));
 115         a4->target = buffer3_to_buffer4(a3->target);
 116         a4->pid = a3->pid;
 117         a4->args.tag = UIDOPT_4;
 118         a4->args.Args_4_u.uidopt = uid3_to_uidopt(a3->args.Args_3_u.key, opt);
 119         return(a4);
 120 }
 121
 122 extern Registration_Status_4
 123 _DtCm_regstat3_to_regstat4(Registration_Status_3 s)
 124 {
 125         switch(s) {
 126         case registered_3:
 127                 return(registered_4);
 128         case failed_3:
 129                 return(failed_4);
 130         case deregistered_3:
 131                 return(deregistered_4);
 132         case confused_3:
 133                 return(confused_4);
 134         default:
 135                 return(failed_4);
 136         }
 137 }
 138
 139 extern Registration_4 *
 140 _DtCm_reg3_to_reg4(Registration_3 *r3)
 141 {
 142         Registration_4 *r4, *head, *prev;
 143
 144         prev = head = NULL;
 145         while (r3 != NULL) {
 146                 r4 = (Registration_4 *)calloc(1, sizeof(Registration_4));
 147                 r4->target = buffer3_to_buffer4(r3->target);
 148                 r4->prognum = r3->prognum;
 149                 r4->versnum = r3->versnum;
 150                 r4->procnum = r3->procnum;
 151                 r4->next = NULL;
 152                 r4->pid = r3->pid;
 153
 154                 if (head == NULL)
 155                         head = r4;
 156                 else
 157                         prev->next = r4;
 158                 prev = r4;
 159
 160                 r3 = r3->next;
 161         }
 162         return(head);
 163 }
 164
 165 extern Table_Status_4
 166 _DtCm_tablestat3_to_tablestat4(Table_Status_3 s)
 167 {
 168         switch(s) {
 169         case ok_3:
 170                 return(ok_4);
 171         case duplicate_3:
 172                 return(duplicate_4);
 173         case badtable_3:
 174                 return(badtable_4);
 175         case notable_3:
 176                 return(notable_4);
 177         case denied_3:
 178                 return(denied_4);
 179         case other_3:
 180         default:
 181                 return(other_4);
 182         }
 183 }
 184
 185 static void
 186 assign_period3to4(Period_3 *p3, Period_4 *p4)
 187 {
 188         switch (p3->period) {
 189
 190         case single_3: p4->period = single_4;
 191                         break;
 192
 193         case daily_3: p4->period = daily_4;
 194                         break;
 195
 196         case weekly_3: p4->period = weekly_4;
 197                         break;
 198
 199         case biweekly_3: p4->period = biweekly_4;
 200                         break;
 201
 202         case monthly_3: p4->period = monthly_4;
 203                         break;
 204
 205         case yearly_3: p4->period = yearly_4;
 206                         break;
 207
 208         case nthWeekday_3: p4->period = nthWeekday_4;
 209                         break;
 210
 211         case everyNthDay_3: p4->period = everyNthDay_4;
 212                         break;
 213
 214         case everyNthWeek_3: p4->period = everyNthWeek_4;
 215                         break;
 216
 217         case everyNthMonth_3: p4->period = everyNthMonth_4;
 218                         break;
 219
 220         case otherPeriod_3: p4->period = otherPeriod_4;
 221                         break;
 222         }
 223 }
 224
 225 static void
 226 assign_tag3to4(Tag_3 *t3, Tag_4 *t4)
 227 {
 228         switch (t3->tag) {
 229
 230         case appointment_3: t4->tag = appointment_4;
 231                         break;
 232
 233         case reminder_3: t4->tag = reminder_4;
 234                         break;
 235
 236         case otherTag_3: t4->tag = otherTag_4;
 237                         break;
 238
 239         case holiday_3: t4->tag = holiday_4;
 240                         break;
 241
 242         case toDo_3: t4->tag = toDo_4;
 243                         break;
 244         }
 245 }
 246
 247 static void
 248 assign_privacy3to4(Privacy_Level_3 *p3, Privacy_Level_4 *p4)
 249 {
 250         switch (*p3) {
 251
 252         case public_3: *p4 = public_4;
 253                         break;
 254
 255         case private_3: *p4 = private_4;
 256                         break;
 257
 258         case semiprivate_3: *p4 = semiprivate_4;
 259                         break;
 260         }
 261 }
 262
 263 static void
 264 assign_status3to4(Appt_Status_3 *s3, Appt_Status_4 *s4)
 265 {
 266         switch (*s3) {
 267
 268         case active_3: *s4 = active_4;
 269                         break;
 270
 271         case pendingAdd_3: *s4 = pendingAdd_4;
 272                         break;
 273
 274         case pendingDelete_3: *s4 = pendingDelete_4;
 275                         break;
 276
 277         case committed_3: *s4 = committed_4;
 278                         break;
 279
 280         case cancelled_3: *s4 = cancelled_4;
 281                         break;
 282
 283         case completed_3: *s4 = completed_4;
 284                         break;
 285         }
 286 }
 287
 288 static Buffer_4
 289 buffer3_to_buffer4(Buffer_3 b)
 290 {
 291         Buffer_4 copy;
 292         if (b!=NULL)
 293                 copy = strdup(b);
 294         else
 295                 copy = calloc(1, 1);
 296         return(copy);
 297 }
 298
 299 static void
 300 period3_to_period4(Period_3 *p3, Period_4 *p4)
 301 {
 302         if (p3 == NULL || p4==NULL) return;
 303         assign_period3to4(p3, p4);
 304         p4->nth = p3->nth;
 305 }
 306
 307 static Tag_4 *
 308 tag3_to_tag4(Tag_3 *t3)
 309 {
 310         Tag_4 *t4, *head, *prev;
 311
 312         prev = head = NULL;
 313         while (t3 != NULL) {
 314                 t4 = (Tag_4 *)calloc(1, sizeof(Tag_4));
 315                 assign_tag3to4(t3, t4);
 316                 t4->showtime = t3->showtime;
 317                 t4->next = NULL;
 318
 319                 if (head == NULL)
 320                         head = t4;
 321                 else
 322                         prev->next = t4;
 323                 prev = t4;
 324
 325                 t3 = t3->next;
 326         }
 327         return(head);
 328 }
 329
 330 static Attribute_4 *
 331 attr3_to_attr4(Attribute_3 *a3)
 332 {
 333         Attribute_4 *a4, *head, *prev;
 334
 335         prev = head = NULL;
 336         while (a3 != NULL) {
 337                 a4 = (Attribute_4 *)calloc(1, sizeof(Attribute_4));
 338                 a4->next = NULL;
 339                 a4->attr = buffer3_to_buffer4(a3->attr);
 340                 a4->value = buffer3_to_buffer4(a3->value);
 341                 a4->clientdata = buffer3_to_buffer4(a3->clientdata);
 342
 343                 if (head == NULL)
 344                         head = a4;
 345                 else
 346                         prev->next = a4;
 347                 prev = a4;
 348
 349                 a3 = a3->next;
 350         }
 351         return(head);
 352 }
 353
 354 static Except_4 *
 355 except3_to_except4(Except_3 *e3)
 356 {
 357         Except_4 *e4, *head, *prev;
 358
 359         prev = head = NULL;
 360         while (e3 != NULL) {
 361                 e4  = (Except_4 *)calloc(1, sizeof(Except_4));
 362                 e4->ordinal = e3->ordinal;
 363                 e4->next=NULL;
 364
 365                 if (head == NULL)
 366                         head = e4;
 367                 else
 368                         prev->next = e4;
 369                 prev = e4;
 370
 371                 e3 = e3->next;
 372         }
 373         return(head);
 374 }
 375
 376 static void
 377 id3_to_id4(Id_3 *from, Id_4 *to)
 378 {
 379         if ((from==NULL) || (to==NULL)) return;
 380         to->tick = from->tick;
 381         to->key = from->key;
 382 }
 383
 384 static Uid_4 *
 385 uid3_to_uid4(Uid_3 *ui3)
 386 {
 387         Uid_4 *ui4, *head, *prev;
 388
 389         prev = head = NULL;
 390         while (ui3 != NULL) {
 391                 ui4 = (Uid_4 *)calloc(1, sizeof(Uid_4));
 392                 id3_to_id4(&(ui3->appt_id), &(ui4->appt_id));
 393                 ui4->next = NULL;
 394
 395                 if (head == NULL)
 396                         head = ui4;
 397                 else
 398                         prev->next = ui4;
 399                 prev = ui4;
 400
 401                 ui3 = ui3->next;
 402         }
 403         return(head);
 404 }
 405
 406 static Appt_4 *
 407 appt3_to_appt4(Appt_3 *a3)
 408 {
 409         Appt_4 *a4, *head, *prev;
 410
 411         prev = head = NULL;
 412         while (a3 != NULL) {
 413                 a4  = (Appt_4 *)calloc(1, sizeof(Appt_4));
 414                 id3_to_id4(&(a3->appt_id), &(a4->appt_id));
 415                 a4->tag = tag3_to_tag4(a3->tag);
 416                 a4->duration = a3->duration;
 417                 a4->ntimes = a3->ntimes;
 418                 a4->what = buffer3_to_buffer4(a3->what);
 419                 period3_to_period4(&(a3->period), &(a4->period));
 420                 a4->author = buffer3_to_buffer4(a3->author);
 421                 a4->client_data = buffer3_to_buffer4(a3->client_data);
 422                 a4->exception = except3_to_except4(a3->exception);
 423                 a4->attr = attr3_to_attr4(a3->attr);
 424                 assign_status3to4(&a3->appt_status, &a4->appt_status);
 425                 assign_privacy3to4(&a3->privacy, &a4->privacy);
 426                 a4->next = NULL;
 427
 428                 if (head == NULL)
 429                         head = a4;
 430                 else
 431                         prev->next = a4;
 432                 prev = a4;
 433
 434                 a3 = a3->next;
 435         }
 436         return(head);
 437 }
 438
 439 static Abb_Appt_4 *
 440 abb3_to_abb4(Abb_Appt_3 *a3)
 441 {
 442         Abb_Appt_4 *a4, *head, *prev;
 443
 444         prev = head = NULL;
 445         while (a3 != NULL) {
 446                 a4 = (Abb_Appt_4 *)calloc(1, sizeof(Abb_Appt_4));
 447                 id3_to_id4(&(a3->appt_id), &(a4->appt_id));
 448                 a4->tag = tag3_to_tag4(a3->tag);
 449                 a4->what = buffer3_to_buffer4(a3->what);
 450                 a4->duration = a3->duration;
 451                 period3_to_period4(&(a3->period), &(a4->period));
 452                 assign_status3to4(&a3->appt_status, &a4->appt_status);
 453                 assign_privacy3to4(&a3->privacy, &a4->privacy);
 454
 455                 a4->next = NULL;
 456
 457                 if (head == NULL)
 458                         head = a4;
 459                 else
 460                         prev->next = a4;
 461                 prev = a4;
 462
 463                 a3 = a3->next;
 464         }
 465         return(head);
 466 }
 467
 468 static void
 469 apptid3_to_apptid4(Apptid_3 *from, Apptid_4 *to)
 470 {
 471         if (from==NULL || to==NULL) return;
 472         id3_to_id4(from->oid, to->oid);
 473         to->new_appt = appt3_to_appt4(from->new_appt);
 474         /* do_all is the default, the caller needs to
 475          * modify it to the appropriate value
 476          */
 477         to->option = do_all_4;
 478 }
 479
 480 static Reminder_4 *
 481 reminder3_to_reminder4(Reminder_3 *r3)
 482 {
 483         Reminder_4 *r4, *head, *prev;
 484         Attribute_4 *attr4;
 485
 486         prev = head = NULL;
 487         while (r3 != NULL) {
 488                 r4 = (Reminder_4 *)calloc(1, sizeof(Reminder_4));
 489                 id3_to_id4(&(r3->appt_id), &(r4->appt_id));
 490                 r4->tick = r3->tick;
 491                 attr4 = attr3_to_attr4(&(r3->attr));
 492                 r4->attr = *attr4;
 493                 free(attr4);
 494                 r4->next = NULL;
 495
 496                 if (head == NULL)
 497                         head = r4;
 498                 else
 499                         prev->next = r4;
 500                 prev = r4;
 501
 502                 r3 = r3->next;
 503         }
 504         return(head);
 505 }
 506
 507 static Table_Res_Type_4
 508 tablerestype3_to_tablerestype4(Table_Res_Type_3 t)
 509 {
 510         switch(t) {
 511         case AP_3:
 512                 return(AP_4);
 513         case RM_3:
 514                 return(RM_4);
 515         case AB_3:
 516                 return(AB_4);
 517         case ID_3:
 518                 return(ID_4);
 519         default:
 520                 return(AP_4);
 521         }
 522 }
 523
 524 static void
 525 tablereslist3_to_tablereslist4(Table_Res_List_3 *from, Table_Res_List_4 *to)
 526 {
 527         if (from==NULL || to==NULL) return;
 528         to->tag = tablerestype3_to_tablerestype4(from->tag);
 529         switch (from->tag) {
 530         case AP_3:
 531                 to->Table_Res_List_4_u.a = appt3_to_appt4(
 532                         from->Table_Res_List_3_u.a);
 533                 break;
 534         case RM_3:
 535                 to->Table_Res_List_4_u.r = reminder3_to_reminder4(
 536                         from->Table_Res_List_3_u.r);
 537                 break;
 538         case AB_3:
 539                 to->Table_Res_List_4_u.b = abb3_to_abb4(
 540                         from->Table_Res_List_3_u.b);
 541                 break;
 542         case ID_3:
 543                 to->Table_Res_List_4_u.i = uid3_to_uid4(
 544                         from->Table_Res_List_3_u.i);
 545                 break;
 546         default:
 547                 return;
 548         }
 549 }
 550
 551 static Access_Entry_4 *
 552 acclist3_to_acclist4(Access_Entry_3 *l3)
 553 {
 554         Access_Entry_4 *l4, *head, *prev;
 555
 556         prev = head = NULL;
 557         while (l3 != NULL) {
 558                 l4 = (Access_Entry_4 *)calloc(1, sizeof(Access_Entry_4));
 559                 l4->who = buffer3_to_buffer4(l3->who);
 560                 l4->access_type = l3->access_type;
 561                 l4->next = NULL;
 562
 563                 if (head == NULL)
 564                         head = l4;
 565                 else
 566                         prev->next = l4;
 567                 prev = l4;
 568
 569                 l3 = l3->next;
 570         }
 571         return(head);
 572 }
 573
 574 static Range_4 *
 575 range3_to_range4(Range_3 *r3)
 576 {
 577         Range_4 *r4, *head, *prev;
 578
 579         prev = head = NULL;
 580         while (r3 != NULL) {
 581                 r4 = (Range_4 *)calloc(1, sizeof(Range_4));
 582                 r4->key1 = r3->key1;
 583                 r4->key2 = r3->key2;
 584                 r4->next = NULL;
 585
 586                 if (head == NULL)
 587                         head = r4;
 588                 else
 589                         prev->next = r4;
 590                 prev = r4;
 591
 592                 r3 = r3->next;
 593         }
 594         return(head);
 595 }
 596
 597 static Keyrange_4 *
 598 keyrange3_to_keyrange4(Keyrange_3 *r3)
 599 {
 600         Keyrange_4 *r4, *head, *prev;
 601
 602         prev = head = NULL;
 603         while (r3 != NULL) {
 604                 r4 = (Keyrange_4 *)calloc(1, sizeof(Keyrange_4));
 605                 r4->key = r3->key;
 606                 r4->tick1 = r3->tick1;
 607                 r4->tick2 = r3->tick2;
 608                 r4->next = NULL;
 609
 610                 if (head == NULL)
 611                         head = r4;
 612                 else
 613                         prev->next = r4;
 614                 prev = r4;
 615
 616                 r3 = r3->next;
 617         }
 618         return(head);
 619 }
 620
 621 static Table_Args_Type_4
 622 argstag3_to_argstag4(Table_Args_Type_3 t)
 623 {
 624         switch(t) {
 625         case TICK_3:
 626                 return(TICK_4);
 627         case APPTID_3:
 628                 return(APPTID_4);
 629         case UID_3:
 630                 return(UID_4);
 631         case APPT_3:
 632                 return(APPT_4);
 633         case RANGE_3:
 634                 return(RANGE_4);
 635         case KEYRANGE_3:
 636                 return(KEYRANGE_4);
 637         default:
 638                 return(TICK_4);
 639         }
 640 }
 641
 642 static void
 643 args3_to_args4(Args_3 *from, Args_4 *to)
 644 {
 645         if (from==NULL || to==NULL) return;
 646         to->tag = argstag3_to_argstag4(from->tag);
 647         switch(from->tag) {
 648         case TICK_3:
 649                 to->Args_4_u.tick = from->Args_3_u.tick;
 650                 break;
 651         case APPTID_3:
 652                 to->Args_4_u.apptid.oid = (Id_4 *)calloc(1, sizeof(Id_4));
 653                 apptid3_to_apptid4(
 654                         &(from->Args_3_u.apptid),
 655                         &(to->Args_4_u.apptid));
 656                 break;
 657         case UID_3:
 658                 to->Args_4_u.key = uid3_to_uid4(from->Args_3_u.key);
 659                 break;
 660         case APPT_3:
 661                 to->Args_4_u.appt = appt3_to_appt4(from->Args_3_u.appt);
 662                 break;
 663         case RANGE_3:
 664                 to->Args_4_u.range = range3_to_range4(from->Args_3_u.range);
 665                 break;
 666         case KEYRANGE_3:
 667                 to->Args_4_u.keyrange = keyrange3_to_keyrange4(
 668                         from->Args_3_u.keyrange);
 669         default:
 670                 break;
 671         }
 672 }
 673
 674 static Uidopt_4 *
 675 uid3_to_uidopt(Uid_3 *uid3, Options_4 opt)
 676 {
 677         Uidopt_4 *uidopt, *head, *prev;
 678
 679         prev = head = NULL;
 680         while (uid3 != NULL) {
 681                 uidopt = (Uidopt_4 *)calloc(1, sizeof(Uidopt_4));
 682                 id3_to_id4(&(uid3->appt_id), &(uidopt->appt_id));
 683                 uidopt->option = opt;
 684                 uidopt->next = NULL;
 685
 686                 if (head == NULL)
 687                         head = uidopt;
 688                 else
 689                         prev->next = uidopt;
 690                 prev = uidopt;
 691
 692                 uid3 = uid3->next;
 693         }
 694         return(head);
 695 }
 696