示例#1
0
文件: cget.c 项目: nagyistge/ctn
static CONDITION
selectCallback(IDB_Query * queryResponse, long count, LST_HEAD * lst)
{
    QUERY_LIST_ITEM
    * item;
    IDB_InstanceListElement
	* e1, *e2;

    item = malloc(sizeof(*item));
    if (item == NULL)
	return 0;

    item->query = *queryResponse;
    if (queryResponse->image.InstanceList != NULL) {
	item->query.image.InstanceList = LST_Create();
	if (item->query.image.InstanceList == NULL)
	    return 0;
	e1 = LST_Head(&queryResponse->image.InstanceList);
	(void) LST_Position(&queryResponse->image.InstanceList, e1);
	while (e1 != NULL) {
	    e2 = malloc(sizeof(*e2));
	    *e2 = *e1;
	    (void) LST_Enqueue(&item->query.image.InstanceList, e2);
	    e1 = LST_Next(&queryResponse->image.InstanceList);
	}
    }
    (void) LST_Enqueue(&lst, item);
    return IDB_NORMAL;
}
示例#2
0
CONDITION
DUL_AddSinglePresentationCtx(DUL_ASSOCIATESERVICEPARAMETERS* params,
			DUL_SC_ROLE proposedRole, DUL_SC_ROLE acceptedRole,
			DUL_PRESENTATIONCONTEXTID contextID,
			unsigned char result, const char* abstractSyntax,
			const char** xferSyntaxes, int xferSyntaxCount)
{
  LST_HEAD* lst;
  DUL_TRANSFERSYNTAX* transfer;
  DUL_PRESENTATIONCONTEXT* ctx;
  CONDITION cond;


  ctx = (DUL_PRESENTATIONCONTEXT *) CTN_MALLOC(sizeof(*ctx));
  if (ctx == NULL)
    return COND_PushCondition(DUL_MALLOCERROR, DUL_Message(DUL_MALLOCERROR),
				  "DUL_AddSinglePresentationCtx", sizeof(*ctx));

  (void) memset(ctx, 0, sizeof(*ctx));
  lst = LST_Create();
  if (lst == NULL)
    return COND_PushCondition(DUL_LISTCREATEFAILED,
	      DUL_Message(DUL_LISTCREATEFAILED), "DUL_AddSinglePresentationCtx");

  (ctx)->presentationContextID = contextID;
  (ctx)->result = result;
  (ctx)->proposedSCRole = proposedRole;
  (ctx)->acceptedSCRole = acceptedRole;
  strcpy((ctx)->abstractSyntax, abstractSyntax);

  strcpy((ctx)->acceptedTransferSyntax, "");
  for (; xferSyntaxCount-- > 0; xferSyntaxes++) {
    if (strlen(*xferSyntaxes) != 0) {
      transfer = CTN_MALLOC(sizeof(*transfer));
      if (transfer == NULL)
	return COND_PushCondition(DUL_MALLOCERROR, DUL_Message(DUL_MALLOCERROR),
			      "DUL_AddSinglePresentationCtx", sizeof(*transfer));
      strcpy(transfer->transferSyntax, *xferSyntaxes);
      if (LST_Enqueue(&lst, transfer) != LST_NORMAL)
	return COND_PushCondition(DUL_LISTERROR, DUL_Message(DUL_LISTERROR),
					  "DUL_AddSinglePresentationCtx");
    }
  }

  (ctx)->proposedTransferSyntax = lst;
  cond = LST_Enqueue(&params->requestedPresentationContext,ctx);
  if (cond != LST_NORMAL) {
    return COND_PushCondition(DUL_LISTERROR, DUL_Message(DUL_LISTERROR),
	    "DUL_AddSinglePresentationCtx");
    /* Memory Leak here */
  }
  return DUL_NORMAL;


}
示例#3
0
文件: srv1.c 项目: bhavik86/Dicom
CONDITION
SRV_RegisterSOPClassXfer(const char *SOPClass, const char* xferSyntax, DUL_SC_ROLE role, DUL_ASSOCIATESERVICEPARAMETERS * params)
{
  DUL_PRESENTATIONCONTEXTID 	contextID = 1;
  CONDITION 					cond;
  DUL_PRESENTATIONCONTEXT* 		ctx;

  if (params->requestedPresentationContext == NULL){
	  params->requestedPresentationContext = LST_Create();
	  if (params->requestedPresentationContext == NULL) return COND_PushCondition(SRV_LISTFAILURE, SRV_Message(SRV_LISTFAILURE), "SRV_RegisterSOPClassXfer");
  }

  ctx = LST_Head(&params->requestedPresentationContext);
  if (ctx != NULL) (void) LST_Position(&params->requestedPresentationContext, ctx);

  while (ctx != NULL) {
	  DUL_TRANSFERSYNTAX* 	xferItem;

	  contextID += 2;
	  xferItem = (DUL_TRANSFERSYNTAX*) LST_Head(&ctx->proposedTransferSyntax);

	  if ((strcmp(SOPClass, ctx->abstractSyntax) == 0) && (strcmp(xferSyntax, xferItem->transferSyntax) == 0) && (role == ctx->proposedSCRole)) return SRV_NORMAL;
	  ctx = LST_Next(&params->requestedPresentationContext);
  }

  cond = DUL_MakePresentationCtx(&ctx, role, DUL_SC_ROLE_DEFAULT, contextID, 0, SOPClass, "", xferSyntax, NULL);
  if (cond != DUL_NORMAL) return COND_PushCondition(SRV_PRESENTATIONCONTEXTERROR, SRV_Message(SRV_PRESENTATIONCONTEXTERROR), "SRV_RegisterSOPClassXfer");

  cond = LST_Enqueue(&params->requestedPresentationContext, ctx);
  if (cond != LST_NORMAL) return COND_PushCondition(SRV_LISTFAILURE, SRV_Message(SRV_LISTFAILURE), "SRV_RegisterSOPClassXfer");

  return SRV_NORMAL;
}
示例#4
0
文件: srv1.c 项目: bhavik86/Dicom
CONDITION
SRV_RegisterSOPClass(const char *SOPClass, DUL_SC_ROLE role, DUL_ASSOCIATESERVICEPARAMETERS * params)
{
  DUL_PRESENTATIONCONTEXTID 	contextID = 1;
  CONDITION 					cond;
  DUL_PRESENTATIONCONTEXT* 		ctx;

  if (params->requestedPresentationContext == NULL) {
	  params->requestedPresentationContext = LST_Create();
	  if (params->requestedPresentationContext == NULL) return COND_PushCondition(SRV_LISTFAILURE, SRV_Message(SRV_LISTFAILURE), "SRV_RegisterSOPClass");
  }

  ctx = LST_Head(&params->requestedPresentationContext);
  if (ctx != NULL) (void) LST_Position(&params->requestedPresentationContext, ctx);

  while (ctx != NULL) {
	  contextID += 2;
	  if (strcmp(SOPClass, ctx->abstractSyntax) == 0) return SRV_NORMAL;
	  ctx = LST_Next(&params->requestedPresentationContext);
  }

  cond = DUL_MakePresentationCtx(&ctx, role, DUL_SC_ROLE_DEFAULT, contextID, 0, SOPClass, "", DICOM_TRANSFERLITTLEENDIAN, NULL);
  if (cond != DUL_NORMAL) return COND_PushCondition(SRV_PRESENTATIONCONTEXTERROR, SRV_Message(SRV_PRESENTATIONCONTEXTERROR), "SRV_RegisterSOPClass");

  cond = LST_Enqueue(&params->requestedPresentationContext, ctx);
  if (cond != LST_NORMAL) return COND_PushCondition(SRV_LISTFAILURE, SRV_Message(SRV_LISTFAILURE), "SRV_RegisterSOPClass");

  return SRV_NORMAL;
}
示例#5
0
文件: support.c 项目: nagyistge/ctn
void
expandPatientStudy(LST_HEAD * patientList, LST_HEAD * patientStudyList)
{
    FIS_PATIENTRECORD
    * p;
    FIS_STUDYRECORD
	* s;
    RSA_PATIENTSTUDY
	* ps;

    clearPatientStudy(patientStudyList);
    p = LST_Head(&patientList);
    if (p != NULL)
	(void) LST_Position(&patientList, p);
    while (p != NULL) {
	s = LST_Head(&p->StudyList);
	if (s != NULL)
	    (void) LST_Position(&p->StudyList, s);
	while (s != NULL) {
	    ps = malloc(sizeof(*ps));
	    ps->Patient = *p;
	    ps->Study = *s;
	    (void) LST_Enqueue(&patientStudyList, ps);
	    s = LST_Next(&p->StudyList);
	}
	p = LST_Next(&patientList);
    }
}
示例#6
0
文件: ref_item.c 项目: nagyistge/ctn
CONDITION
MSG_BuildReferencedItemSequence(MSG_REFERENCED_ITEM * item,
				LST_HEAD ** list)
{
    CONDITION
	cond;
    DCM_SEQUENCE_ITEM
	* sq;

    if (*list == NULL) {
	*list = LST_Create();
	if (*list == NULL)
	    return COND_PushCondition(MSG_LISTFAILURE,
	    MSG_Message(MSG_LISTFAILURE), "MSG_BuildReferencedItemSequence");
    }
    sq = CTN_MALLOC(sizeof(*sq));
    if (sq == NULL)
	return COND_PushCondition(MSG_MALLOCFAILURE,
				MSG_Message(MSG_MALLOCFAILURE), sizeof(*sq),
				  "MSG_BuildReferencedItemSequence");

    cond = MSG_BuildCommand(item, &sq->object);
    if (cond != MSG_NORMAL)
	return cond;

    cond = LST_Enqueue(list, item);
    if (cond != LST_NORMAL)
	return COND_PushCondition(MSG_LISTFAILURE,
	   MSG_Message(MSG_LISTFAILURE), "MSG_BuildReferencedItemSequence");
    return MSG_NORMAL;
}
示例#7
0
文件: fisget.c 项目: ccteng/dicomprop
static CONDITION
commitSOPRefCallback(TBL_FIELD * field, int count, LST_HEAD * l)
{
    FIS_COMMITSOPREFRECORD *r;
    CONDITION cond;
    int i;
    static FLAG_MAP map[] = {
	{"TraUID", FIS_K_COMMITSOP_TRAUID},
	{"SOPClaUID", FIS_K_COMMITSOP_SOPCLAUID},
	{"SOPInsUID", FIS_K_COMMITSOP_SOPINSUID}
    };

    commitSOPRef.Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    commitSOPRef.Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (l != NULL) {
	r = malloc(sizeof(*r));
	if (r == NULL)
	    return TBL_EARLYEXIT;

	*r = commitSOPRef;
	if (LST_Enqueue(&l, r) != LST_NORMAL)
	    return TBL_EARLYEXIT;
    }
    return TBL_NORMAL;
}
示例#8
0
文件: mb_query.c 项目: nagyistge/ctn
static CONDITION
queryCallback(MSG_C_FIND_REQ * request, MSG_C_FIND_RESP * response,
	    int responseCount, char *SOPClass, char *queryLevel, void *p)
{
  ITEM* item;
  LST_HEAD* l;

  if (response->status == MSG_K_SUCCESS)
    return SRV_NORMAL;

  MSG_DumpMessage(response, stdout);

  if (p == 0)
    return SRV_NORMAL;

  item = calloc(1, sizeof(*item));
  if (item == 0) {
    fprintf(stderr, "Could not allocate %d bytes\n", sizeof(*item));
    exit(1);
  }

  DCM_CopyObject(&response->identifier, &item->obj);
  l = (LST_HEAD*)p;
  LST_Enqueue(&l, item);

  return SRV_NORMAL;
}
示例#9
0
文件: ddr.c 项目: ccteng/dicomprop
static CONDITION
addSeriesRecord(DCM_OBJECT ** seriesObject, LST_HEAD ** lst)
{
    CONDITION cond;
    DDR_SERIES record,
       *seriesPtr;
    DCM_ELEMENT required[] = {
	{DCM_IDMODALITY, DCM_CS, "", 1, sizeof(record.Modality), NULL},
	{DCM_RELSERIESINSTANCEUID, DCM_UI, "", 1,
	sizeof(record.SeriesInstanceUID), NULL},
	{DCM_RELSERIESNUMBER, DCM_IS, "", 1,
	sizeof(record.SeriesNumber), NULL},
	{DCM_DIRLOWERLEVELOFFSET, DCM_UL, "", 1,
	sizeof(record.LeafLinkOffset), NULL}
    };

    required[0].d.string = record.Modality;
    required[1].d.string = record.SeriesInstanceUID;
    required[2].d.string = record.SeriesNumber;
    required[3].d.ul = &record.LeafLinkOffset;

    memset(&record, 0, sizeof(record));
    cond = DCM_ParseObject(seriesObject, required,
			   (int) DIM_OF(required), NULL, 0, NULL);
    if (cond != DCM_NORMAL) {
	return 0;		/* repair */
    }
    seriesPtr = malloc(sizeof(*seriesPtr));
    if (seriesPtr == NULL) {
	return 0;		/* repair */
    }
    memcpy(seriesPtr, &record, sizeof(record));
    LST_Enqueue(lst, seriesPtr);
    return DDR_NORMAL;
}
示例#10
0
文件: fisget.c 项目: ccteng/dicomprop
static CONDITION
workQueueCallback(TBL_FIELD * field, int count, LST_HEAD * l)
{
    FIS_WORKQUEUERECORD *r;
    CONDITION cond;
    int i;
    static FLAG_MAP map[] = {
	{"TasNam", FIS_K_WORKQUEUE_TASNAM},
	{"TasID", FIS_K_WORKQUEUE_TASID}
    };

    workQueue.Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    workQueue.Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (l != NULL) {
	r = malloc(sizeof(*r));
	if (r == NULL)
	    return TBL_EARLYEXIT;

	*r = workQueue;
	if (LST_Enqueue(&l, r) != LST_NORMAL)
	    return TBL_EARLYEXIT;
    }
    return TBL_NORMAL;
}
示例#11
0
文件: support.c 项目: nagyistge/ctn
CONDITION
extractGroups(LST_HEAD * src, LST_HEAD * dst)
{
    DMAN_GROUPNAMES
	* s,
	*p;

    s = LST_Head(&src);
    if (s != NULL)
	(void) LST_Position(&src, s);

    while (s != NULL) {
	p = LST_Head(&dst);
	if (p != NULL)
	    (void) LST_Position(&dst, p);
	while (p != NULL) {
	    if (strcmp(s->GroupName, p->GroupName) == 0)
		break;
	    else
		p = LST_Next(&dst);
	}
	if (p == NULL) {
	    p = malloc(sizeof(*p));
	    if (p == NULL)
		return 0;
	    *p = *s;
	    (void) LST_Enqueue(&dst, p);
	}
	s = LST_Next(&src);
    }
    return 1;
}
示例#12
0
CONDITION UTL_ScanDirectory(const char* path,
			    LST_HEAD** lst)
{
  UTL_FILEITEM* item = 0;

#ifdef _WIN32
  long hFile = 0;
  struct _finddata_t fileInfo;
  char directoryText[1024];
  *lst = LST_Create();
  strcpy(directoryText, path);
  strcat(directoryText, "/*");
  if( (hFile = _findfirst(directoryText, &fileInfo)) == -1L)
    return 0;

  item = malloc(sizeof(*item));
  strcpy(item->path, fileInfo.name);
  LST_Enqueue(lst, item);

  while(_findnext(hFile, &fileInfo) == 0) {
    item = malloc(sizeof(*item));
    strcpy(item->path, fileInfo.name);
    LST_Enqueue(lst, item);
  }
  _findclose(hFile);

#else
  DIR* dirp;
  struct dirent* dp;

  *lst = LST_Create();
  dirp = opendir(path);
  if (dirp == 0)
    return 0;

  while ((dp = readdir(dirp)) != NULL) {
    item = malloc(sizeof(*item));
    strcpy(item->path, dp->d_name);
    LST_Enqueue(lst, item);
  }
  closedir(dirp);
#endif

  return UTL_NORMAL;
}
示例#13
0
static int
requestAssociation(DUL_NETWORKKEY ** network,
		   DUL_ASSOCIATIONKEY ** association,
		 DUL_ASSOCIATESERVICEPARAMETERS * params, char **SOPClasses,
		   int classCount)
{
    CONDITION
    cond;
    DUL_PRESENTATIONCONTEXT
	* ctx;
    static DUL_PRESENTATIONCONTEXTID
        contextID = 1;

    if (params->requestedPresentationContext == NULL) {
	params->requestedPresentationContext = LST_Create();
	if (params->requestedPresentationContext == NULL) {
	    return 0;
	}
    }
    while (classCount-- > 0) {
	ctx = malloc(sizeof(*ctx));
	if (ctx == NULL)
	    return 0;

	cond = DUL_MakePresentationCtx(&ctx, DUL_SC_ROLE_DEFAULT,
				       DUL_SC_ROLE_DEFAULT,
				       contextID, 0, *SOPClasses++, "",
				       DICOM_TRANSFERLITTLEENDIAN,
				       DICOM_TRANSFERLITTLEENDIANEXPLICIT,
				       DICOM_TRANSFERBIGENDIANEXPLICIT,
				       NULL);
	if (cond != DUL_NORMAL)
	    return 0;
	else {
	    cond = LST_Enqueue(&params->requestedPresentationContext, ctx);
	    if (cond != LST_NORMAL)
		return 0;

	    contextID += 2;
	}
    }
    cond = DUL_RequestAssociation(network, params, association);
    if (cond != DUL_NORMAL) {
	if (cond == DUL_ASSOCIATIONREJECTED) {
	    fprintf(stderr, "Association Rejected\n");
	    fprintf(stderr, " Result: %2x Source %2x Reason %2x\n",
		    params->result, params->resultSource,
		    params->diagnostic);
	}
	return 0;
    }
    (void) printf("Association accepted, parameters:\n");
    DUL_DumpParams(params);
    return 1;
}
示例#14
0
文件: fisget.c 项目: ccteng/dicomprop
static CONDITION
storageCommitCallback(TBL_FIELD * field, int count, LST_HEAD * l)
{
    FIS_STORAGECOMMITREQRECORD *r;
    CONDITION cond;
    int i;
    static FLAG_MAP map[] = {
	{"TraUID", FIS_K_SCOMMIT_TRAUID},
	{"ReqAE", FIS_K_SCOMMIT_REQAE},
	{"ResAE", FIS_K_SCOMMIT_RESAE},
	{"ReqDat", FIS_K_SCOMMIT_REQDAT},
	{"ReqTim", FIS_K_SCOMMIT_REQTIM},
	{"ResDat", FIS_K_SCOMMIT_RESDAT},
	{"ResTim", FIS_K_SCOMMIT_RESTIM}
    };

    storageCommitRequest.Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    storageCommitRequest.Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (storageCommitRequest.Flag & FIS_K_SCOMMIT_REQDAT)
	UTL_ConvertLongtoDate((long) commitRequestDate,
			      storageCommitRequest.ReqDat);
    if (storageCommitRequest.Flag & FIS_K_SCOMMIT_REQDAT)
	UTL_ConvertLongtoDate((long) commitResponseDate,
			      storageCommitRequest.ResDat);
    if (storageCommitRequest.Flag & FIS_K_SCOMMIT_REQTIM)
	UTL_ConvertFloattoTime(commitRequestTime,
			       storageCommitRequest.ReqTim);
    if (storageCommitRequest.Flag & FIS_K_SCOMMIT_RESTIM)
	UTL_ConvertFloattoTime(commitResponseTime,
			       storageCommitRequest.ResTim);


    if (l != NULL) {
	r = malloc(sizeof(*r));
	if (r == NULL)
	    return TBL_EARLYEXIT;

	*r = storageCommitRequest;
	if (LST_Enqueue(&l, r) != LST_NORMAL)
	    return TBL_EARLYEXIT;
    }
    return TBL_NORMAL;
}
示例#15
0
CONDITION
DUL_MakePresentationCtx(DUL_PRESENTATIONCONTEXT ** ctx,
		     DUL_SC_ROLE proposedSCRole, DUL_SC_ROLE acceptedSCRole,
		      DUL_PRESENTATIONCONTEXTID ctxID, unsigned char result,
			const char *abstractSyntax, const char *transferSyntax,...)
{
    va_list
	args;
    LST_HEAD
	* lst;
    DUL_TRANSFERSYNTAX
	* transfer;
#ifdef lint
    char __builtin_va_alist;
#endif

    *ctx = (DUL_PRESENTATIONCONTEXT *) CTN_MALLOC(sizeof(**ctx));
    if (*ctx == NULL)
	return COND_PushCondition(DUL_MALLOCERROR, DUL_Message(DUL_MALLOCERROR),
				  "DUL_MakePresentationCtx", sizeof(**ctx));

    (void) memset(*ctx, 0, sizeof(**ctx));
    lst = LST_Create();
    if (lst == NULL)
	return COND_PushCondition(DUL_LISTCREATEFAILED,
	      DUL_Message(DUL_LISTCREATEFAILED), "DUL_MakePresentationCtx");

    (*ctx)->presentationContextID = ctxID;
    (*ctx)->result = result;
    (*ctx)->proposedSCRole = proposedSCRole;
    (*ctx)->acceptedSCRole = acceptedSCRole;
    strcpy((*ctx)->abstractSyntax, abstractSyntax);

    va_start(args, transferSyntax);
    strcpy((*ctx)->acceptedTransferSyntax, transferSyntax);
    while ((transferSyntax = va_arg(args, char *)) != NULL) {
	if (strlen(transferSyntax) != 0) {
	    transfer = CTN_MALLOC(sizeof(*transfer));
	    if (transfer == NULL)
		return COND_PushCondition(DUL_MALLOCERROR, DUL_Message(DUL_MALLOCERROR),
			      "DUL_MakePresentationCtx", sizeof(*transfer));
	    strcpy(transfer->transferSyntax, transferSyntax);
	    if (LST_Enqueue(&lst, transfer) != LST_NORMAL)
		return COND_PushCondition(DUL_LISTERROR, DUL_Message(DUL_LISTERROR),
					  "DUL_MakePresentationCtx");
	}
    }
    va_end(args);
    (*ctx)->proposedTransferSyntax = lst;
    return DUL_NORMAL;
}
示例#16
0
文件: hap.c 项目: ccteng/dicomprop
CONDITION
IAP_InstanceArraytoElement(char *SOPArray, size_t SOPSpacing,
	      char *UIDArray, size_t UIDSpacing, int count, DCM_ELEMENT * e)
{
    CONDITION
	cond;
    DCM_ELEMENT
	classElement = {
	DCM_IDREFERENCEDSOPCLASSUID, DCM_UI, "", 1, 0, NULL
    },
	uidElement = {
	DCM_IDREFERENCEDSOPINSTUID, DCM_UI, "", 1, 0, NULL
    };
    DCM_OBJECT
	* object;
    DCM_SEQUENCE_ITEM
	* item;

    e->d.sq = LST_Create();
    if (e->d.sq == NULL)
	return 0;		/* repair */

    while (count-- > 0) {
	item = malloc(sizeof(*item));
	if (item == NULL)
	    return 0;		/* repair */
	cond = DCM_CreateObject(&item->object);
	if (cond != DCM_NORMAL)
	    return 0;		/* repair */
	classElement.d.string = SOPArray;
	classElement.length = strlen(SOPArray);
	cond = DCM_AddElement(&item->object, &classElement);
	if (cond != DCM_NORMAL)
	    return 0;		/* repair */
	uidElement.d.string = UIDArray;
	uidElement.length = strlen(UIDArray);
	cond = DCM_AddElement(&item->object, &uidElement);
	if (cond != DCM_NORMAL)
	    return 0;		/* repair */

	cond = LST_Enqueue(&e->d.sq, item);
	if (cond != LST_NORMAL)
	    return 0;		/* repair */

	SOPArray += SOPSpacing;
	UIDArray += UIDSpacing;
    }
    return HAP_NORMAL;
}
示例#17
0
文件: fisget.c 项目: ccteng/dicomprop
static CONDITION
studyCallback(TBL_FIELD * field, int count, LST_HEAD * l)
{
    FIS_STUDYRECORD
    * s;

    int i;
    static FLAG_MAP map[] = {
	{"PatUID", FIS_K_STU_PATUID},
	{"StuInsUID", FIS_K_STU_STUINSUID},
	{"VisUID", FIS_K_STU_VISUID},
	{"AccNum", FIS_K_STU_ACCNUM},
	{"StuID", FIS_K_STU_STUID},
	{"SchStuStaDat", FIS_K_STU_SCHSTUSTADAT},
	{"SchStuStaTim", FIS_K_STU_SCHSTUSTATIM},
	{"SchStuLoc", FIS_K_STU_SCHSTULOC},
	{"ProDes", FIS_K_STU_PRODES},
	{"StuStaID", FIS_K_STU_STUSTAID}
    };


    study.Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    study.Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (study.Flag & FIS_K_STU_SCHSTUSTADAT)
	UTL_ConvertLongtoDate((long) studyDate, study.SchStuStaDat);
    if (study.Flag & FIS_K_STU_SCHSTUSTATIM)
	UTL_ConvertFloattoTime(studyTime, study.SchStuStaTim);
    if (l != NULL) {
	s = malloc(sizeof(*s));
	if (s == NULL)
	    return TBL_EARLYEXIT;

	*s = study;
	if (LST_Enqueue(&l, s) != LST_NORMAL)
	    return TBL_EARLYEXIT;
    }
    return TBL_NORMAL;
}
示例#18
0
文件: select.c 项目: nagyistge/ctn
static CONDITION
callbackAE(TBL_FIELD * field, int count, void *ctxArg)
{
    DMAN_APPLICATIONENTITY
    * ae,
    *localAE;
    CONDITION
	cond;
    int
        i;
    static FLAG_MAP
        map[] = {
	{"Title", DMAN_K_APPLICATION_TITLE},
	{"Node", DMAN_K_APPLICATION_NODE},
	{"Port", DMAN_K_APPLICATION_PORT},
	{"Comment", DMAN_K_APPLICATION_COMMENT},
	{"Organization", DMAN_K_APPLICATION_ORGANIZATION},
    };
    CONTEXT *ctx;

    ctx = (CONTEXT *) ctxArg;

    ae = (DMAN_APPLICATIONENTITY *) ctx->record;
    ae->Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    ae->Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (*ctx->lst != NULL) {
	localAE = malloc(sizeof(*localAE));
	if (localAE == NULL)
	    return 0;
	*localAE = *ae;


	cond = LST_Enqueue(ctx->lst, localAE);
	if (cond != LST_NORMAL)
	    return 0;
    }
    return TBL_NORMAL;
}
示例#19
0
static void
groupCallback(unsigned short group, char *description, void *ctx)
{
    DCM_ELEMENT_NODE *n;
    LST_HEAD **l;

    l = (LST_HEAD **) ctx;
    n = calloc(1, sizeof(*n));
    if (n == NULL)
	return;

    n->e.tag = DCM_MAKETAG(group, 0);
    strcpy(n->e.description, description);

    (void) LST_Enqueue(l, n);
}
示例#20
0
文件: select.c 项目: nagyistge/ctn
static CONDITION
callbackFA(TBL_FIELD * field, int count, void *ctxArg)
{
    DMAN_FISACCESS
    * sa,
    *localSA;
    CONDITION
	cond;
    int
        i;
    static FLAG_MAP
        map[] = {
	{"Title", DMAN_K_FISACCESS_TITLE},
	{"DbKey", DMAN_K_FISACCESS_DBKEY},
	{"Owner", DMAN_K_FISACCESS_OWNER},
	{"GroupName", DMAN_K_FISACCESS_GROUPNAME},
	{"Comment", DMAN_K_FISACCESS_COMMENT}
    };
    CONTEXT *ctx;

    ctx = (CONTEXT *) ctxArg;

    sa = (DMAN_FISACCESS *) ctx->record;
    sa->Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    sa->Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (*ctx->lst != NULL) {
	localSA = malloc(sizeof(*localSA));
	if (localSA == NULL)
	    return 0;

	*localSA = *sa;
	cond = LST_Enqueue(ctx->lst, localSA);
	if (cond != LST_NORMAL)
	    return 0;
    }
    return TBL_NORMAL;
}
示例#21
0
文件: select.c 项目: nagyistge/ctn
static CONDITION
callbackStorageControl(TBL_FIELD * field, int count, void *ctxArg)
{
    DMAN_STORAGECONTROL
    * s,
    *localStorage;
    CONDITION
	cond;
    int
        i;
    static FLAG_MAP
        map[] = {
	{"RequestingTitle", DMAN_K_STORAGECONTROL_REQUESTING},
	{"RespondingTitle", DMAN_K_STORAGECONTROL_RESPONDING},
	{"Medium", DMAN_K_STORAGECONTROL_MEDIUM},
	{"Root", DMAN_K_STORAGECONTROL_ROOT}
    };
    CONTEXT *ctx;

    ctx = (CONTEXT *) ctxArg;

    s = (DMAN_STORAGECONTROL *) ctx->record;
    s->Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    s->Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (*ctx->lst != NULL) {
	localStorage = malloc(sizeof(*localStorage));
	if (localStorage == NULL)
	    return 0;
	*localStorage = *s;


	cond = LST_Enqueue(ctx->lst, localStorage);
	if (cond != LST_NORMAL)
	    return 0;
    }
    return TBL_NORMAL;
}
示例#22
0
CONDITION UTL_ReadConfigFile( )
{
  FILE* f;
  char buf[1024];

  if (UTL_configList != 0)
    return UTL_NORMAL;

  UTL_configList = LST_Create();
  if (UTL_configList == NULL)
    return 0;

  if (UTL_configFile == 0)
    return UTL_NORMAL;

  if (UTL_configFile[0] == '\0')
    return UTL_NORMAL;

  f = fopen(UTL_configFile, "r");
  if (f == NULL)
    return 0;

  while (fgets(buf, sizeof(buf), f) != NULL) {
    char* token1;
    char* token2;
    CONFIG_ITEM* item;

    if (buf[0] == '#') continue;
    if (buf[0] == '\n') continue;
    token1 = strtok(buf, " \t\n");
    token2 = strtok(0, " \t\n");
    if (token2 == NULL) continue;

    item = (CONFIG_ITEM*)malloc(sizeof(*item) + strlen(token1) +
				strlen(token2) + 2);
    item->pName = ((char*)item) + sizeof(*item);
    strcpy(item->pName, token1);
    item->pValue = item->pName + strlen(token1) + 1;
    strcpy(item->pValue, token2);

    LST_Enqueue(&UTL_configList, item);
  }

  fclose(f);

  return UTL_NORMAL;
}
示例#23
0
文件: fisget.c 项目: ccteng/dicomprop
static CONDITION
interpretationCallback(TBL_FIELD * field, int count, LST_HEAD * l)
{
    FIS_INTERPRETATIONRECORD *r;
    CONDITION cond;
    int i;
    static FLAG_MAP map[] = {
	{"IntUID", FIS_K_INTERP_INTUID},
	{"ResUID", FIS_K_INTERP_RESUID},
	{"IntID", FIS_K_INTERP_INTID},
	{"IntTex", FIS_K_INTERP_INTTEX},
	{"IntDiaDes", FIS_K_INTERP_INTDIADES},
	{"IntTypID", FIS_K_INTERP_INTTYPID},
	{"IntStaID", FIS_K_INTERP_INTSTAID},
	{"InsCreDat", FIS_K_INTERP_INSCREDAT},
	{"InsCreTim", FIS_K_INTERP_INSCRETIM},
	{"InsCreUID", FIS_K_INTERP_INSCREUID},
	{"PhyAppInt", FIS_K_INTERP_PHYAPPINT},
	{"IntAppDat", FIS_K_INTERP_INTAPPDAT},
	{"IntAppTim", FIS_K_INTERP_INTAPPTIM}
    };

    interpretation.Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    interpretation.Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (l != NULL) {
	r = malloc(sizeof(*r));
	if (r == NULL)
	    return TBL_EARLYEXIT;

	*r = interpretation;
	if (LST_Enqueue(&l, r) != LST_NORMAL)
	    return TBL_EARLYEXIT;
    }
    return TBL_NORMAL;
}
示例#24
0
static void
elementCallback(DCM_TAG tag, char *description,
		DCM_VALUEREPRESENTATION representation, void *ctx)
{
    DCM_ELEMENT_NODE *n;
    LST_HEAD **l;

    l = (LST_HEAD **) ctx;
    n = calloc(1, sizeof(*n));
    if (n == NULL)
	return;

    n->e.tag = tag;
    strcpy(n->e.description, description);
    n->e.representation = representation;

    (void) LST_Enqueue(l, n);
}
示例#25
0
文件: icon.c 项目: nagyistge/ctn
/* ICON_GetStudyIconLst
**
** Purpose:
**      Reads the file and returns a list of STUDYICON records corresponding
**	to a study identified by an accession number.
**
** Parameter Dictionary:
**      file                    Pathname of the file.
**      studyiconlist         	List of STUDYICON records.
**
** Return Values:
**      ICON_NORMAL             Sucess
**      ICON_FILEOPENFAILED     Failed to open file.
**      ICON_LISTFAILURE        Failed to create/enqueue list.
**	ICON_OFFSETERROR	Failed to search file.
**      ICON_MALLOCFAILURE      Failed to malloc memory space.
**      ICON_INCORRECTFILESIZE  Failed to parse file properly.
**
** Notes:
**
** Algorithm:
**      Description of the algorithm (optional) and any other notes.
*/
CONDITION
ICON_GetStudyIconLst(char *file, ICON_STUDYOFFSET * studyoffset, LST_HEAD ** studyiconlist)
{
    int
        fd,
        fdcond;
    LIST_ICON_STUDYICON
	* listitem;
    ICON_STUDYICON
	temp;
    CONDITION
	cond;

    fd = open(file, O_RDONLY);
    if (fd < 0)
	return COND_PushCondition(ICON_FILEOPENFAILED,
	   ICON_Message(ICON_FILEOPENFAILED), file, "ICON_GetStudyIconLst");
    *studyiconlist = LST_Create();
    if (*studyiconlist == NULL)
	return COND_PushCondition(ICON_LISTFAILURE,
		    ICON_Message(ICON_LISTFAILURE), "ICON_GetStudyIconLst");
    if (lseek(fd, studyoffset->Offset, SEEK_SET) < 0)
	return COND_PushCondition(ICON_OFFSETERROR,
		    ICON_Message(ICON_OFFSETERROR), "ICON_GetStudyIconLst");
    while (((fdcond = read(fd, (char *) &temp, sizeof(ICON_STUDYICON))) ==
	    sizeof(ICON_STUDYICON)) &&
	   (!strcmp(temp.accessionNumber, studyoffset->accessionNumber))) {
	listitem = (LIST_ICON_STUDYICON *) malloc(sizeof(LIST_ICON_STUDYICON));
	if (listitem == NULL)
	    return COND_PushCondition(ICON_MALLOCFAILURE,
		  ICON_Message(ICON_MALLOCFAILURE), "ICON_GetStudyIconLst");
	listitem->studyicon = temp;
	cond = LST_Enqueue(studyiconlist, listitem);
	if (cond != LST_NORMAL)
	    return COND_PushCondition(ICON_LISTFAILURE,
		    ICON_Message(ICON_LISTFAILURE), "ICON_GetStudyIconLst");
    }
    if ((fdcond != sizeof(ICON_STUDYICON)) && (fdcond != 0))
	return COND_PushCondition(ICON_INCORRECTFILESIZE,
	      ICON_Message(ICON_INCORRECTFILESIZE), "ICON_GetStudyIconLst");

    close(fd);
    return (ICON_NORMAL);
}
示例#26
0
文件: select.c 项目: nagyistge/ctn
static CONDITION
callbackGroup(TBL_FIELD * field, int count, void *ctxArg)
{
    DMAN_GROUPNAMES
    * g,
    *localGroup;
    CONDITION
	cond;
    int
        i;
    static FLAG_MAP
        map[] = {
	{"Title", DMAN_K_GROUP_TITLE},
	{"GroupName", DMAN_K_GROUP_GROUP},
    };
    CONTEXT *ctx;

    ctx = (CONTEXT *) ctxArg;
    g = (DMAN_GROUPNAMES *) ctx->record;
    g->Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    g->Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (*ctx->lst != NULL) {
	localGroup = malloc(sizeof(*localGroup));
	if (localGroup == NULL)
	    return 0;
	*localGroup = *g;


	cond = LST_Enqueue(ctx->lst, localGroup);
	if (cond != LST_NORMAL)
	    return 0;
    }
    return TBL_NORMAL;
}
示例#27
0
文件: fisget.c 项目: ccteng/dicomprop
static CONDITION
studyComponentCallback(TBL_FIELD * field, int count, LST_HEAD * l)
{
    FIS_STUDYCOMPONENTRECORD
    * s;

    int i;
    static FLAG_MAP map[] = {
	{"StuComUID", FIS_K_STUDYCOMP_STUCOMUID},
	{"StuInsUID", FIS_K_STUDYCOMP_STUINSUID},
	{"Mod", FIS_K_STUDYCOMP_MOD},
	{"StuDes", FIS_K_STUDYCOMP_STUDES},
	{"ProCodVal", FIS_K_STUDYCOMP_PROCODVAL},
	{"ProCodSch", FIS_K_STUDYCOMP_PROCODSCHDES},
	{"ProCodMea", FIS_K_STUDYCOMP_PROCODMEA},
	{"StuComStaID", FIS_K_STUDYCOMP_STUCOMSTAID},
	{"StuID", FIS_K_STUDYCOMP_STUID},
    };


    studyComponent.Flag = 0;
    while (field->FieldName != NULL) {
	for (i = 0; i < (int) DIM_OF(map); i++) {
	    if (strcmp(field->FieldName, map[i].FieldName) == 0) {
		if (!field->Value.IsNull)
		    studyComponent.Flag |= map[i].Flag;
		break;
	    }
	}
	field++;
    }

    if (l != NULL) {
	s = malloc(sizeof(*s));
	if (s == NULL)
	    return TBL_EARLYEXIT;

	*s = studyComponent;
	if (LST_Enqueue(&l, s) != LST_NORMAL)
	    return TBL_EARLYEXIT;
    }
    return TBL_NORMAL;
}
示例#28
0
文件: ddr.c 项目: ccteng/dicomprop
static CONDITION
addStudyRecord(DCM_OBJECT ** studyObject, LST_HEAD ** lst)
{
    CONDITION cond;
    DDR_STUDY record,
       *studyPtr;
    DCM_ELEMENT required[] = {
	{DCM_IDSTUDYDATE, DCM_DA, "", 1, sizeof(record.StudyDate), NULL},
	{DCM_IDSTUDYTIME, DCM_TM, "", 1, sizeof(record.StudyTime), NULL},
	{DCM_IDSTUDYDESCRIPTION, DCM_LO, "", 1,
	sizeof(record.StudyDescription), NULL},
	{DCM_RELSTUDYINSTANCEUID, DCM_UI, "", 1,
	sizeof(record.StudyInstanceUID), NULL},
	{DCM_RELSTUDYID, DCM_SH, "", 1, sizeof(record.StudyID), NULL},
	{DCM_IDACCESSIONNUMBER, DCM_SH, "", 1,
	sizeof(record.AccessionNumber), NULL},
	{DCM_DIRLOWERLEVELOFFSET, DCM_UL, "", 1,
	sizeof(record.SeriesLinkOffset), NULL}
    };

    required[0].d.string = record.StudyDate;
    required[1].d.string = record.StudyTime;
    required[2].d.string = record.StudyDescription;
    required[3].d.string = record.StudyInstanceUID;
    required[4].d.string = record.StudyID;
    required[5].d.string = record.AccessionNumber;
    required[6].d.ul = &record.SeriesLinkOffset;

    memset(&record, 0, sizeof(record));
    cond = DCM_ParseObject(studyObject, required,
			   (int) DIM_OF(required), NULL, 0, NULL);
    if (cond != DCM_NORMAL) {
	return 0;		/* repair */
    }
    studyPtr = malloc(sizeof(*studyPtr));
    if (studyPtr == NULL) {
	return 0;		/* repair */
    }
    memcpy(studyPtr, &record, sizeof(record));
    LST_Enqueue(lst, studyPtr);
    return DDR_NORMAL;
}
示例#29
0
文件: ddr.c 项目: ccteng/dicomprop
static CONDITION
addLeafRecord(DCM_OBJECT ** leafObject, LST_HEAD ** lst)
{
    CONDITION cond;
    DDR_SERIES_LEAF record,
       *leafPtr;
    DCM_ELEMENT required[] = {
	{DCM_DIRRECORDTYPE, DCM_CS, "", 1, sizeof(record.RecordType), NULL},
	{DCM_DIRREFERENCEDFILEID, DCM_CS, "", 1,
	sizeof(record.FileID), NULL},
	{DCM_DIRREFSOPCLASSUID, DCM_UI, "", 1,
	sizeof(record.SOPClassUID), NULL},
	{DCM_DIRREFSOPINSTANCEUID, DCM_UI, "", 1,
	sizeof(record.SOPInstanceUID), NULL},
	{DCM_DIRREFTRANSFERSYNTAXUID, DCM_UI, "", 1,
	sizeof(record.TransferSyntaxUID), NULL}
    };

    required[0].d.string = record.RecordType;
    required[1].d.string = record.FileID;
    required[2].d.string = record.SOPClassUID;
    required[3].d.string = record.SOPInstanceUID;
    required[4].d.string = record.TransferSyntaxUID;

    memset(&record, 0, sizeof(record));
    cond = DCM_ParseObject(leafObject, required,
			   (int) DIM_OF(required), NULL, 0, NULL);
    if (cond != DCM_NORMAL) {
	return 0;		/* repair */
    }
    if (strcmp(record.RecordType, "IMAGE") == 0)
	addImageLeafAttributes(leafObject, &record);

    leafPtr = malloc(sizeof(*leafPtr));
    if (leafPtr == NULL) {
	return 0;		/* repair */
    }
    memcpy(leafPtr, &record, sizeof(record));
    LST_Enqueue(lst, leafPtr);

    return DDR_NORMAL;
}
示例#30
0
文件: srv1.c 项目: bhavik86/Dicom
CONDITION
SRV_RejectServiceClass(DUL_PRESENTATIONCONTEXT * requestedCtx, unsigned short result, DUL_ASSOCIATESERVICEPARAMETERS * params)
{
    CONDITION					cond;
    DUL_PRESENTATIONCONTEXT		* ctx;

    if (params->acceptedPresentationContext == NULL) {
    	params->acceptedPresentationContext = LST_Create();
    	if (params->acceptedPresentationContext == NULL) return COND_PushCondition(SRV_LISTFAILURE, SRV_Message(SRV_LISTFAILURE), "SRV_RejectServiceClass");
    }

    cond = DUL_MakePresentationCtx(&ctx, requestedCtx->proposedSCRole, DUL_SC_ROLE_DEFAULT, requestedCtx->presentationContextID, (unsigned char)result,
								   requestedCtx->abstractSyntax, DICOM_TRANSFERLITTLEENDIAN, DICOM_TRANSFERLITTLEENDIAN, NULL);
    if (cond != DUL_NORMAL) return COND_PushCondition(SRV_PRESENTATIONCONTEXTERROR, SRV_Message(SRV_PRESENTATIONCONTEXTERROR), "SRV_RejectServiceClass");

    cond = LST_Enqueue(&params->acceptedPresentationContext, ctx);
    if (cond != LST_NORMAL)	return COND_PushCondition(SRV_LISTFAILURE, SRV_Message(SRV_LISTFAILURE), "SRV_RejectServiceClass");

    return SRV_NORMAL;
}