← Back to branch summary

~ubuntu-branches/ubuntu/trusty/sblim-sfcb/trusty-proposed

« back to all changes in this revision

Viewing changes to providerMgr.c

  • Committer: Bazaar Package Importer
  • Author(s): Thierry Carrez
  • Date: 2009-06-08 12:04:49 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090608120449-byfplk09rqz8rtg6
Tags: 1.3.3-0ubuntu1
* New upstream release.
* debian/rules: Removed rpath hacks, SFCB default build handles that now.
* Removed 1934753-remove-assignment.diff, now upstream.
* Refreshed patch cim-schema-location.diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
providerMgr.c
1
1
 
2
2
/*
3
 
 * $Id: providerMgr.c,v 1.50 2008/04/16 17:41:29 gdread Exp $
 
3
 * $Id: providerMgr.c,v 1.58 2009/02/02 20:02:03 mchasal Exp $
4
4
 *
5
5
 * © Copyright IBM Corp. 2005, 2007
6
6
 *
120
120
   free(req);
121
121
}
122
122
 
123
 
/*
124
 
static void handleSigterm(int sig)
125
 
{
126
 
   mlogf(M_ERROR,M_SHOW, "%s: exiting due to signal %d\n", "provider", sig);
127
 
   exit(1);
128
 
}
129
 
 
130
 
static void handleSigSegv(int sig)
131
 
{
132
 
   mlogf(M_ERROR,M_SHOW, "()%d): exiting due to a SIGSEGV signal %d - %s(%d)\n",
133
 
           currentProc, sig, __FILE__, __LINE__);
134
 
   abort();
135
 
}
136
 
*/
137
 
 
138
 
 
139
123
/* -------------
140
124
 * ---
141
125
 *      Instance Provider support
194
178
   _SFCB_RETURN(0);
195
179
}
196
180
 
 
181
/*
 
182
 * Find the provider for className residing in nameSpace
 
183
 * If none is found for that specific class, try the parent class
 
184
 * If still none, return DefaultProvider
 
185
 *
 
186
 */
197
187
static ProviderInfo *lookupProvider(long type, char *className, char *nameSpace, 
198
188
      CMPIStatus *st)
199
189
{
371
361
   unsigned long count,n;
372
362
   ProviderInfo *info;
373
363
   int dmy = 0, rc,indFound=0;
374
 
   char *msg = NULL;
375
364
   CMPIStatus st = {CMPI_RC_OK, NULL};
376
365
 
377
366
   providers = lookupProviders(type,className,nameSpace,&st);
383
372
      for (info = providers->ft->getFirst(providers); info;
384
373
           info = providers->ft->getNext(providers), n--) {
385
374
         if (info->type!=FORCE_PROVIDER_NOTFOUND &&
386
 
             (rc = forkProvider(info, req, &msg)) == CMPI_RC_OK) {
 
375
             (rc = forkProvider(info, req, NULL)) == CMPI_RC_OK) {
387
376
            _SFCB_TRACE(1,("--- responding with  %s %p %d",info->providerName,info,count));
388
377
            spSendCtlResult(requestor, &info->providerSockets.send,
389
378
                MSG_X_PROVIDER, count--, getProvIds(info).ids, req->options);
395
384
            };
396
385
            spSendCtlResult(requestor, &dmy, MSG_X_PROVIDER_NOT_FOUND, 0,
397
386
               NULL, req->options);
398
 
            if (msg) free(msg);
399
387
            break;
400
388
         }
401
389
      }
414
402
   char *className = (char *) req->className.data;
415
403
   char *nameSpace = (char *) req->nameSpace.data;
416
404
   ProviderInfo *info;
417
 
   char *msg=NULL;
418
405
   int rc;
419
406
   CMPIStatus st;
420
407
 
422
409
   
423
410
   if ((info = lookupProvider(type,className,nameSpace,&st)) != NULL) {
424
411
      if (info->type!=FORCE_PROVIDER_NOTFOUND &&
425
 
          (rc = forkProvider(info, req, &msg)) == CMPI_RC_OK) {
 
412
          (rc = forkProvider(info, req, NULL)) == CMPI_RC_OK) {
426
413
         spSendCtlResult(requestor, &info->providerSockets.send, MSG_X_PROVIDER,
427
414
            0, getProvIds(info).ids, req->options);
428
415
      }                   
429
416
      else {
430
417
         spSendCtlResult(requestor, &sfcbSockets.send, MSG_X_PROVIDER_NOT_FOUND, 0, 
431
418
            NULL, req->options);
432
 
         if (msg) free(msg);
433
419
      }
434
420
   }
435
421
   else {
599
585
   long count = 0;
600
586
   ProviderInfo *info;
601
587
   int dmy = 0, rc;
602
 
   char *msg=NULL;
603
588
 
604
589
   if (className==NULL || *className == 0)
605
590
      className = "$ASSOCCLASSES$";
611
596
         for (info = providers->ft->getFirst(providers); info;
612
597
              info = providers->ft->getNext(providers)) {
613
598
            if (info->type!=FORCE_PROVIDER_NOTFOUND &&
614
 
                (rc = forkProvider(info, req, &msg)) == CMPI_RC_OK) {
 
599
                (rc = forkProvider(info, req, NULL)) == CMPI_RC_OK) {
615
600
               _SFCB_TRACE(1,("--- responding with  %s %p %d",info->providerName,info,count));
616
601
               spSendCtlResult(requestor, &info->providerSockets.send,
617
602
                  MSG_X_PROVIDER, count--, getProvIds(info).ids, req->options);
619
604
            else {
620
605
               spSendCtlResult(requestor, &dmy, MSG_X_PROVIDER_NOT_FOUND,
621
606
                  0, NULL, req->options);
622
 
               if (msg) free(msg);
623
607
               break;
624
608
            }
625
 
 
626
609
         }
627
610
      }
628
611
      else {
634
617
      /* When there is no provider for an assocClass we do not want to produce
635
618
       * an error message. So we return the default provider and expect it
636
619
       * to produce a nice and empty result */
637
 
      if((rc = forkProvider(defaultProvInfoPtr, req, &msg)) == CMPI_RC_OK) {
 
620
      if((rc = forkProvider(defaultProvInfoPtr, req, NULL)) == CMPI_RC_OK) {
638
621
         _SFCB_TRACE(1,("--- responding with  %s %p %d",
639
622
                        defaultProvInfoPtr->providerName,
640
623
                        defaultProvInfoPtr,count));
642
625
         MSG_X_PROVIDER, count--, getProvIds(defaultProvInfoPtr).ids,
643
626
                                                       req->options);
644
627
      }
 
628
     else 
 
629
       {
 
630
         /* Oops, even creation of the default provider failed */
 
631
         mlogf(M_ERROR,M_SHOW,"--- forkProvider failed for defaultProvider\n");
 
632
         /*      spSendCtlResult(requestor, &dmy, MSG_X_PROVIDER_NOT_FOUND, 0,
 
633
          NULL, req->options); */
 
634
         _SFCB_ABORT();
 
635
       }     
645
636
   }
646
637
   _SFCB_EXIT();
647
638
}
705
696
 
706
697
static void classProvider(int *requestor, OperationHdr * req)
707
698
{
708
 
   char *msg;
709
 
 
 
699
  int rc;
710
700
   _SFCB_ENTER(TRACE_PROVIDERMGR, "classProvider");
711
 
   forkProvider(classProvInfoPtr, req, &msg);
 
701
   rc = forkProvider(classProvInfoPtr, req, NULL);
 
702
   if (rc != CMPI_RC_OK)
 
703
    {
 
704
      mlogf(M_ERROR,M_SHOW,"--- forkProvider failed in classProvider\n");
 
705
      /*      spSendCtlResult(requestor, &dmy, MSG_X_PROVIDER_NOT_FOUND, 0,
 
706
               NULL, req->options); */
 
707
      _SFCB_ABORT();
 
708
    }
 
709
  
712
710
   _SFCB_TRACE(1,("--- result %d-%lu to with %d-%lu",
713
711
      *requestor,getInode(*requestor),
714
712
      classProvInfoPtr->providerSockets.send,
716
714
   
717
715
   spSendCtlResult(requestor, &classProvInfoPtr->providerSockets.send, MSG_X_PROVIDER,
718
716
      0, getProvIds(classProvInfoPtr).ids, req->options);
719
 
                                   
720
717
   _SFCB_EXIT();
721
718
}
722
719
 
723
720
static void qualiProvider(int *requestor, OperationHdr * req)
724
721
{
725
 
   char *msg;
726
 
   
 
722
   int rc;
727
723
   _SFCB_ENTER(TRACE_PROVIDERMGR, "qualiProvider");
728
 
   forkProvider(qualiProvInfoPtr, req, &msg);
 
724
   rc = forkProvider(qualiProvInfoPtr, req, NULL);
 
725
   if (rc != CMPI_RC_OK)
 
726
    {
 
727
      mlogf(M_ERROR,M_SHOW,"--- forkProvider failed in qualiProvider\n");
 
728
      /*      spSendCtlResult(requestor, &dmy, MSG_X_PROVIDER_NOT_FOUND, 0,
 
729
               NULL, req->options); */
 
730
      _SFCB_ABORT();
 
731
    }
729
732
   _SFCB_TRACE(1,("--- result %d-%lu to with %d-%lu",   
730
733
      *requestor,getInode(*requestor),
731
734
      qualiProvInfoPtr->providerSockets.send,
738
741
 
739
742
static void methProvider(int *requestor, OperationHdr * req)
740
743
{
741
 
   char *msg=NULL;
742
744
   int rc;
743
745
   char *className = (char *) req->className.data;
744
746
   char *nameSpace = (char *) req->nameSpace.data;
748
750
   if (strcmp(className, "$ClassProvider$") == 0)
749
751
      classProvider(requestor, req);
750
752
   else if ((info = getMethodProvider(className,nameSpace)) != NULL) {
 
753
      rc = CMPI_RC_OK;
751
754
      if (info->type!=FORCE_PROVIDER_NOTFOUND &&
752
 
          (rc = forkProvider(info, req, &msg)) == CMPI_RC_OK) {
 
755
          (rc = forkProvider(info, req, NULL)) == CMPI_RC_OK) {
753
756
         _SFCB_TRACE(1,("--- responding with  %s %p",info->providerName,info));
754
757
         spSendCtlResult(requestor, &info->providerSockets.send, MSG_X_PROVIDER,
755
758
            0, getProvIds(info).ids, req->options);
756
759
      }                   
757
760
      else {
758
 
         spSendCtlResult(requestor, &sfcbSockets.send, MSG_X_PROVIDER_NOT_FOUND,
 
761
        if (rc != CMPI_RC_OK)
 
762
          {
 
763
            mlogf(M_ERROR,M_SHOW,"--- forkProvider failed in methProvider\n");
 
764
          }
 
765
        
 
766
          spSendCtlResult(requestor, &sfcbSockets.send, MSG_X_PROVIDER_NOT_FOUND,
759
767
            0, NULL, req->options);
760
 
         if (msg) free(msg);
761
768
      }
762
769
   }
763
770
   else
766
773
   _SFCB_EXIT();
767
774
}
768
775
 
 
776
 
769
777
static int _methProvider(BinRequestContext * ctx, OperationHdr * req)
770
778
{
771
779
   _SFCB_ENTER(TRACE_PROVIDERMGR, "_methProvider");
773
781
   char *nameSpace = (char *) req->nameSpace.data;
774
782
   ProviderInfo *info;
775
783
   int rc;
776
 
   char *msg;
777
784
 
778
785
   ctx->chunkedMode=ctx->xmlAs=0;
779
786
   if (strcmp(className, "$ClassProvider$") == 0) {
780
 
      forkProvider(classProvInfoPtr, req, &msg);
 
787
      rc = forkProvider(classProvInfoPtr, req, NULL);
 
788
      if (rc != CMPI_RC_OK)
 
789
        {
 
790
          mlogf(M_ERROR,M_SHOW,"--- forkProvider failed in _methProvider (%s)\n", className);
 
791
      /*      spSendCtlResult(requestor, &dmy, MSG_X_PROVIDER_NOT_FOUND, 0,
 
792
               NULL, req->options); */
 
793
          _SFCB_ABORT();
 
794
        }
781
795
      ctx->provA.ids = getProvIds(classProvInfoPtr);
782
796
      ctx->provA.socket = classProvInfoPtr->providerSockets.send;
783
797
      ctx->pAs=NULL;
784
798
      _SFCB_RETURN(MSG_X_PROVIDER); 
785
799
   }
786
800
   else if (strcmp(className, "$InterOpProvider$") == 0) {
787
 
      forkProvider(interOpProvInfoPtr, req, &msg);
 
801
      rc = forkProvider(interOpProvInfoPtr, req, NULL);
 
802
      if (rc != CMPI_RC_OK)
 
803
        {
 
804
          mlogf(M_ERROR,M_SHOW,"--- forkProvider failed in _methProvider (%s)\n", className);
 
805
      /*      spSendCtlResult(requestor, &dmy, MSG_X_PROVIDER_NOT_FOUND, 0,
 
806
               NULL, req->options); */
 
807
          _SFCB_ABORT();
 
808
        }
788
809
      ctx->provA.ids = getProvIds(interOpProvInfoPtr);
789
810
      ctx->provA.socket = interOpProvInfoPtr->providerSockets.send;
790
811
      ctx->pAs=NULL;
791
812
      _SFCB_RETURN(MSG_X_PROVIDER);
792
813
   }
793
814
   else if ((info = getMethodProvider(className,nameSpace)) != NULL) {
794
 
      if ((rc = forkProvider(info, req, &msg)) == CMPI_RC_OK) {
 
815
      if ((rc = forkProvider(info, req, NULL)) == CMPI_RC_OK) {
795
816
         ctx->provA.ids = getProvIds(info);
796
817
         ctx->provA.socket = info->providerSockets.send;
797
818
         ctx->pAs=NULL; 
798
819
         _SFCB_RETURN(MSG_X_PROVIDER);
799
820
      }
800
 
      else {
801
 
         free(msg);
 
821
      else { 
 
822
         mlogf(M_ERROR,M_SHOW,"--- _methProvider NOT FOUND\n");
 
823
      /*      spSendCtlResult(requestor, &dmy, MSG_X_PROVIDER_NOT_FOUND, 0,
 
824
               NULL, req->options); */
802
825
         _SFCB_RETURN(MSG_X_PROVIDER_NOT_FOUND);
803
826
      }
804
827
   }
 
828
   mlogf(M_ERROR,M_SHOW,"--- _methProvider INVALID\n");
805
829
   _SFCB_RETURN(MSG_X_INVALID_CLASS);
806
830
}
807
831
 
857
881
   _SFCB_ENTER(TRACE_PROVIDERMGR, "processProviderMgrRequests");
858
882
 
859
883
   startUpProvider("root/interop","$ClassProvider$");
860
 
   
 
884
 
861
885
#ifdef SFCB_INCL_INDICATION_SUPPORT
862
886
   if (interOpProvInfoPtr!=forceNoProvInfoPtr) {
863
887
     sleep(2);
912
936
static void setInuseSem(void *id)
913
937
{
914
938
   ProvIds ids;
915
 
 
916
 
   _SFCB_ENTER(TRACE_PROVIDERMGR, "setInuseSem");
917
 
   ids.ids=id;   
918
 
   semAcquire(sfcbSem,(ids.procId*3)+provProcGuardId+provProcBaseId);
919
 
   semAcquire(sfcbSem,(ids.procId*3)+provProcInuseId+provProcBaseId);
920
 
   semReleaseUnDo(sfcbSem,(ids.procId*3)+provProcInuseId+provProcBaseId);
921
 
   semRelease(sfcbSem,(ids.procId*3)+provProcGuardId+provProcBaseId);
 
939
   key_t semKey;
 
940
 
 
941
    _SFCB_ENTER(TRACE_PROVIDERMGR, "setInuseSem");
 
942
   if (sfcbSem < 0) { //Semaphore Not initialized.
 
943
        semKey=ftok(SFCB_BINARY,'S');
 
944
       sfcbSem=semget(semKey,1, 0600);
 
945
   }
 
946
 
 
947
   ids.ids=id;
 
948
 
 
949
   semAcquire(sfcbSem,PROV_GUARD(ids.procId));
 
950
   semAcquire(sfcbSem,PROV_INUSE(ids.procId));
 
951
   semReleaseUnDo(sfcbSem,PROV_INUSE(ids.procId));
 
952
   semRelease(sfcbSem,PROV_GUARD(ids.procId));
922
953
   _SFCB_EXIT();
923
954
}
924
955
 
926
957
int getProviderContext(BinRequestContext * ctx, OperationHdr * ohdr)
927
958
{
928
959
   unsigned long int l;
929
 
   int rc, i, x;
 
960
   int rc=0, i, x;
930
961
   char *buf;
931
962
   ProvAddr *as;
932
963
   ComSockets sockets;
954
985
   
955
986
   _SFCB_TRACE(1,("--- Sending mgr request - to %d from %d", sfcbSockets.send,
956
987
                sockets.send)); 
957
 
   spSendReq(&sfcbSockets.send, &sockets.send, buf, l, localMode);   
 
988
   rc = spSendReq(&sfcbSockets.send, &sockets.send, buf, l, localMode);   
958
989
   free(buf);
959
990
 
 
991
   if (rc < 0) {
 
992
      mlogf(M_ERROR,M_SHOW,"--- spSendReq/spSendMsg failed to send on %d (%d)\n", sfcbSockets.send, rc);
 
993
      ctx->rc = rc;
 
994
      close (sockets.send);
 
995
      close (sockets.receive);
 
996
      return rc;
 
997
   }
 
998
 
960
999
   _SFCB_TRACE(1, ("--- Sending mgr request done"));
961
1000
   
962
1001
   ctx->rc = spRecvCtlResult(&sockets.receive, &ctx->provA.socket, &ctx->provA.ids.ids, &l);
1317
1356
   BinRequestContext binCtx;
1318
1357
   OperationHdr req = { OPS_GetClass, 2 };
1319
1358
   int irc;
1320
 
   char *msg;
1321
1359
   
1322
1360
   path = NewCMPIObjectPath(ns, cn, st);
1323
1361
   sreq.objectPath = setObjectPathMsgSegment(path);
1326
1364
   req.nameSpace = setCharsMsgSegment((char *) ns);
1327
1365
   req.className = setCharsMsgSegment((char *) cn);
1328
1366
 
1329
 
   forkProvider(classProvInfoPtr, &req, &msg);
1330
 
   
 
1367
   irc = forkProvider(classProvInfoPtr, &req, NULL);
 
1368
   if (irc != CMPI_RC_OK) 
 
1369
    {
 
1370
      mlogf(M_ERROR,M_SHOW,"--- forkProvider failed in _getConstClass(%s:%s)\n", ns, cn);
 
1371
      /*      spSendCtlResult(requestor, &dmy, MSG_X_PROVIDER_NOT_FOUND, 0,
 
1372
               NULL, req->options); */
 
1373
      _SFCB_ABORT();
 
1374
    }
 
1375
  
1331
1376
   memset(&binCtx,0,sizeof(BinRequestContext));
1332
1377
   binCtx.oHdr = &req;
1333
1378
   binCtx.bHdr = &sreq.hdr;
1424
1469
 
1425
1470
   irc = _methProvider(&binCtx, &req);
1426
1471
 
1427
 
   if (irc) {
 
1472
   if (irc == MSG_X_PROVIDER) {
1428
1473
      localInvokeMethod(&binCtx, path, "ischild", in, &out, &rc,0);
1429
1474
      irc=(rc.rc==CMPI_RC_OK);
1430
1475
   }
1454
1499
 
1455
1500
   irc = _methProvider(&binCtx, &req);
1456
1501
 
1457
 
   if (irc) {
 
1502
   if (irc == MSG_X_PROVIDER) {
1458
1503
      localInvokeMethod(&binCtx, path, "_startup", in, &out, &rc, 1);
1459
1504
      irc=(rc.rc==CMPI_RC_OK);
1460
1505
   }
1490
1535
 
1491
1536
   irc = _methProvider(&binCtx, &req);
1492
1537
 
1493
 
   if (irc) {
 
1538
   if (irc == MSG_X_PROVIDER) {
1494
1539
      data = localInvokeMethod(&binCtx, path, "getchildren", in, &out, &rc, 0);
1495
1540
      if (out) {
1496
1541
         ar = CMGetArg(out, "children", &rc).value.array;
1532
1577
   memset(&binCtx,0,sizeof(BinRequestContext));
1533
1578
   irc = _methProvider(&binCtx, &req);
1534
1579
 
1535
 
   if (irc) {
 
1580
   if (irc == MSG_X_PROVIDER) {
1536
1581
      data = localInvokeMethod(&binCtx, path, "getassocs", in, &out, &rc,0);
1537
1582
      if (out) {
1538
1583
         ar = CMGetArg(out, "assocs", &rc).value.array;