/*! Loads the libary named lib<libname>.so using dlopen(). \param libname the library name. \return the library handle. */ void * tool_load_lib ( const char * libname ) { char filename[255]; void *dllhand; //PEGASUS_CMPIR_LIBTYPE appends libname with the lib extn based on os. sprintf ( filename, PEGASUS_CMPIR_LIBTYPE, libname ); //invoke dlopen under unix and LoadLibrary under windows OS. dllhand = (void *) PEGASUS_CMPIR_LOADLIBRARY(filename,RTLD_LAZY); if (dllhand == 0) { #if defined PEGASUS_OS_TYPE_UNIX TRACE_CRITICAL( ("Trying to load library: %s failed with %s\n", libname, dlerror()) ); #else TRACE_CRITICAL( ("Trying to load library: %s failed with %s\n", libname, strerror(errno)) ); #endif } return dllhand; }
void start_debugger() { #ifdef PEGASUS_OS_TYPE_UNIX int ch; char * debugger = getenv("RCMPI_DEBUGGER"); if (debugger != NULL) { if ((ch = fork())) { sleep(20); /* wait until debugger traces us */ } else { char pid[10]; char * argv[] = { debugger, "OOP-Provider", pid, NULL}; sprintf(pid, "%d", getppid()); execv(debugger, argv); TRACE_CRITICAL(("could not start debugger \"%s\", " "check RCMPI_DEBUGGER environment " "variable.", debugger)); exit(-1); } } #endif }
// Helper function void __free_ind_object (ind_object *obj) { switch (obj->type) { case PEGASUS_INDICATION_OBJECT_TYPE_CMPI_SELECT_EXP : CMRelease ( (CMPISelectExp*)obj->ptr); break; case PEGASUS_INDICATION_OBJECT_TYPE_CMPI_SELECT_COND: CMRelease ( (CMPISelectCond*)obj->ptr); break; case PEGASUS_INDICATION_OBJECT_TYPE_CMPI_SUB_COND: CMRelease ( (CMPISubCond*)obj->ptr); break; case PEGASUS_INDICATION_OBJECT_TYPE_CMPI_PREDICATE: CMRelease ( (CMPIPredicate*)obj->ptr); break; default : TRACE_CRITICAL(("Unknown Object type: %d", obj->type )); } }
void cleanup_indicationObjects (CMPIUint32 ctx_id) { indication_objects *tmp, *prev; ind_object *obj; TRACE_NORMAL(("Cleaning all Indication Objects.")); INIT_LOCK(_indication_objects_lock); CMPI_BrokerExt_Ftab->lockMutex(_indication_objects_lock); tmp = __indication_objects; while (tmp) { if (tmp->ctx_id == ctx_id) { break; } prev = tmp; tmp = tmp->next; } if (!tmp) { TRACE_CRITICAL(("Indication context id (%u) not found.", ctx_id)); return; } while (tmp->objects) { obj = tmp->objects; tmp->objects = tmp->objects->next; __free_ind_object (obj); } if (tmp == __indication_objects) { __indication_objects = __indication_objects->next; } else { prev->next = tmp->next; } free (tmp); CMPI_BrokerExt_Ftab->unlockMutex(_indication_objects_lock); }
/*! The function evaluates the up-call ticket, retrieves the appropriate broker handle, and passes on the request to __handle_MB_call(), if successful. \param socket the connection socket. */ static void __verify_MB_call(int socket) { comm_ticket ticket; CONST CMPIBroker *broker; TRACE_VERBOSE(("entered function.")); TRACE_NORMAL(("handling incoming broker service request.")); io_read_fixed_length(socket, &ticket, sizeof(comm_ticket)); broker = verify_ticket(&ticket); if (broker == NULL) { TRACE_CRITICAL(("ticket invalid, could not obtain a broker" " handle.")); // return bad status. close(socket); } else __handle_MB_call(socket, broker); TRACE_VERBOSE(("leaving function.")); }
int usbd_mv_ioctl(void *context, unsigned int cmd, unsigned long arg) { struct vhci_device_descriptor *pdev = context; int result = 0; unsigned long flags; struct waitable_queue_entry *pqentry; struct vhci_queue_data *pqdata; PUNRB punrb; TRACE("usbd_mv_ioctl: ++ cmd=%d arg=%lu\n", cmd, arg); switch(cmd) { case 0: /* read unrb */ if( pdev->reset_in_progress ) { TRACE("usbd_mv_ioctl: reset in progress\n"); result = -ENODATA; break; } punrb = (PUNRB)((char*)pdev->readbuf+arg); TRACE("usbd_mv_ioctl: read unrb\n"); /* get next queued urb or unrb */ usbd_wq_lock(&pdev->queue_pending_transfer_unrb,flags); pqentry = usbd_wq_remove_head(&pdev->queue_pending_transfer_unrb); usbd_wq_unlock(&pdev->queue_pending_transfer_unrb,flags); do /*while(0)*/ { if( pqentry == NULL ) { TRACE("usbd_mv_ioctl: no entry\n"); result = -ENODATA; break; } pqdata = (struct vhci_queue_data *)pqentry->data; if( pqdata->purb ) { result = usbd_pack_urb(pqdata->purb, pqdata->unique_id, punrb); if( result != 0 ) { TRACE_CRITICAL("usbd_mv_ioctl: can not pack urb, result=%d\n", result); result = -ENODATA; usbd_vhci_device_complete_urb(pqdata->purb, -EINVAL); break; } dump_unrb(punrb); #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) spin_lock(&pqdata->purb->lock); if( pqdata->purb->status == -EINPROGRESS ) #else if( !pqdata->purb->unlinked ) #endif { /* urb is still pending, put it back into queue */ usbd_wq_add_tail_locked(&pdev->queue_pending_completion_unrb, pqentry); #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) spin_unlock(&pqdata->purb->lock); #endif TRACE("usbd_mv_ioctl: urb copied successfully\n"); /* do not free this entry, as it was queued again */ pqentry = NULL; } else { TRACE("usbd_mv_ioctl: urb has been cancelled!\n"); /* somebody has cancelled the urb while we were messing with it */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) spin_unlock(&pqdata->purb->lock); #endif usbd_vhci_device_complete_urb(pqdata->purb, -1); result = -ENODATA; } break; } if( pqdata->punrb ) { memcpy(punrb, pqdata->punrb, pqdata->punrb->Header.Size); dump_unrb(punrb); if(punrb->Header.Function == UNRB_FUNCTION_RESET_PORT) { pdev->reset_in_progress = 1; /* put unrb into pending queue */ usbd_wq_add_tail_locked(&pdev->queue_pending_completion_unrb, pqentry); pqentry = NULL; } else kfree(pqdata->punrb); TRACE("usbd_mv_ioctl: unrb copied successfully(2)\n"); break; } result = -ENODATA; } while(0); if( pqentry ) usbd_wq_free_entry(pqentry); break; case 1: /* write unrb */ TRACE("usbd_mv_ioctl: write unrb\n"); punrb = (PUNRB)((char*)pdev->writebuf+arg); dump_unrb(punrb); usbd_wq_lock(&pdev->queue_pending_completion_unrb,flags); pqentry = usbd_wq_get_first(&pdev->queue_pending_completion_unrb); while(pqentry) { pqdata = (struct vhci_queue_data *)pqentry->data; if( pqdata->unique_id == punrb->Header.UniqueId ) { usbd_wq_remove_entry(pqentry); break; } pqentry = usbd_wq_get_next(&pdev->queue_pending_completion_unrb, pqentry); } usbd_wq_unlock(&pdev->queue_pending_completion_unrb,flags); if( pqentry ) { pqdata = (struct vhci_queue_data *)pqentry->data; if( pqdata->purb ) { int status; TRACE("usbd_mv_ioctl: unpacking urb\n"); status = usbd_unpack_urb(punrb, pqdata->purb); usbd_vhci_device_complete_urb(pqdata->purb, status); } if( pqdata->punrb ) { if(punrb->Header.Function == UNRB_FUNCTION_RESET_PORT) { TRACE("usbd_mv_ioctl: reset completed\n"); pdev->reset_in_progress = 0; usbd_wq_wake_up(&pdev->queue_pending_transfer_unrb); } TRACE("usbd_mv_ioctl: freeing unrb\n"); kfree(pqdata->punrb); } usbd_wq_free_entry(pqentry); } else { TRACE("usbd_mv_ioctl: urb not found\n"); } break; default: TRACE("usbd_mv_ioctl: invalid request\n"); result = -EINVAL; break; } TRACE("usbd_mv_ioctl: -- result=%d\n", result); return result; }
char * value2Chars ( CMPIType type, CMPIValue * value ) { char str[256],*p; unsigned int size; CMPIString *cStr; TRACE_NORMAL(("value2string type 0x%x CMPIValue.", type)); if (type & CMPI_ARRAY) { // TRACE_INFO(("serializing array object type.")); // return __serialize_CMPIArray ( fd, value->array ); } else if (type & CMPI_ENC) { TRACE_INFO(("trying to stringify encapsulated data type.")); switch (type) { case CMPI_instance: break; case CMPI_ref: cStr=__oft_toString(value->ref,NULL); return strdup((char*)cStr->hdl); break; case CMPI_args: break; case CMPI_filter: break; case CMPI_string: case CMPI_numericString: case CMPI_booleanString: case CMPI_dateTimeString: case CMPI_classNameString: size=(unsigned int) strlen((char*)value->string->hdl); p=malloc(size+8); sprintf(p,"\"%s\"",(char*)value->string->hdl); return strdup(p); case CMPI_dateTime: break; } TRACE_CRITICAL(("non-supported encapsulated data type.")); } else if (type & CMPI_SIMPLE) { TRACE_INFO(("serializing simple value.")); switch (type) { case CMPI_boolean: return strdup(value->boolean ? "true" : "false" ); case CMPI_char16: break; } TRACE_CRITICAL(("non-supported simple data type.")); } else if (type & CMPI_INTEGER) { TRACE_INFO(("serializing integer value.")); switch (type) { case CMPI_uint8: sprintf(str,"%u",value->uint8); return strdup(str); case CMPI_sint8: sprintf(str,"%d",value->sint8); return strdup(str); case CMPI_uint16: sprintf(str,"%u",value->uint16); return strdup(str); case CMPI_sint16: sprintf(str,"%d",value->sint16); return strdup(str); case CMPI_uint32: sprintf(str,"%u",value->uint32); return strdup(str); case CMPI_sint32: sprintf(str,"%d",value->sint32); return strdup(str); case CMPI_uint64: #if defined CMPI_PLATFORM_WIN32_IX86_MSVC sprintf(str,"I64u",value->uint64); #else sprintf(str,"%llu",value->uint64); #endif return strdup(str); case CMPI_sint64: #if defined CMPI_PLATFORM_WIN32_IX86_MSVC sprintf(str,"%I64d",value->sint64); #else sprintf(str,"%lld",value->sint64); #endif return strdup(str); } TRACE_CRITICAL(("non-supported integer data type.")); } else if (type & CMPI_REAL) { switch (type) { case CMPI_real32: sprintf(str,"%g",value->real32); return strdup(str); case CMPI_real64: sprintf(str,"%g",value->real64); return strdup(str); } TRACE_CRITICAL(("non-supported floating point data type.")); } sprintf(str,"*NOT RECOGNIZED VALUE TYPE %d*",type); return strdup(str); }