使用dctmtk实现DICOM文件的发送（StoreSCU）

//=====================================================================
// SendDICOM.cpp : Defines the entry point for the DLL application.
//
//   Created by HGB 2011  Nanjing ChunRen L.T.D
//=====================================================================

#include "stdafx.h"
#include "SendDICOM.h"
#include "osconfig.h" /* make sure OS specific configuration is included first */

#define INCLUDE_CSTDLIB
#define INCLUDE_CSTDIO
#define INCLUDE_CSTRING
#define INCLUDE_CERRNO
#define INCLUDE_CSTDARG
#define INCLUDE_CCTYPE
#include "ofstdinc.h"

BEGIN_EXTERN_C
#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
#endif
END_EXTERN_C

#ifdef HAVE_GUSI_H
#include <GUSI.h>
#endif

#include "ofstring.h"
#include "dimse.h"
#include "diutil.h"
#include "dcdatset.h"
#include "dcmetinf.h"
#include "dcfilefo.h"
#include "dcdebug.h"
#include "dcuid.h"
#include "dcdict.h"
#include "dcdeftag.h"
#include "cmdlnarg.h"
#include "ofconapp.h"
#include "dcuid.h"     /* for dcmtk version name */
#include "dicom.h"     /* for DICOM_APPLICATION_REQUESTOR */
#include "dcostrmz.h"  /* for dcmZlibCompressionLevel */
#include "dcasccfg.h"  /* for class DcmAssociationConfiguration */
#include "dcasccff.h"  /* for class DcmAssociationConfigurationFile */

#ifdef ON_THE_FLY_COMPRESSION
#include "djdecode.h"  /* for dcmjpeg decoders */
#include "djencode.h"  /* for dcmjpeg encoders */
#include "dcrledrg.h"  /* for DcmRLEDecoderRegistration */
#include "dcrleerg.h"  /* for DcmRLEEncoderRegistration */
#endif

#ifdef WITH_OPENSSL
#include "tlstrans.h"
#include "tlslayer.h"
#endif

#include "WINSOCK.H"

#ifdef WITH_ZLIB
#include <zlib.h>          /* for zlibVersion() */
#endif

static E_TransferSyntax opt_networkTransferSyntax = EXS_Unknown;
static OFBool opt_proposeOnlyRequiredPresentationContexts = OFFalse;
static OFBool opt_combineProposedTransferSyntaxes = OFFalse;
static OFCmdUnsignedInt opt_repeatCount = 1;
static OFBool opt_haltOnUnsuccessfulStore = OFTrue;
static OFCmdUnsignedInt opt_inventPatientCount = 25;
static OFCmdUnsignedInt opt_inventStudyCount = 50;
static OFCmdUnsignedInt opt_inventSeriesCount = 100;
static OFBool opt_inventSOPInstanceInformation = OFFalse;
static OFBool opt_correctUIDPadding = OFFalse;
static OFBool unsuccessfulStoreEncountered = OFFalse;
static OFBool opt_verbose = OFFalse;
static OFBool opt_showPresentationContexts = OFFalse;
static OFBool opt_debug = OFFalse;
static OFBool opt_abortAssociation = OFFalse;
static OFCmdUnsignedInt opt_maxReceivePDULength = ASC_DEFAULTMAXPDU;
static OFCmdUnsignedInt opt_maxSendPDULength = 0;
T_DIMSE_BlockingMode opt_blockMode = DIMSE_BLOCKING;
int opt_dimse_timeout = 0;
int opt_acse_timeout = 30;
static int lastStatusCode = STATUS_Success;
static OFString studyIDPrefix("SID_");   // StudyID is SH (maximum 16 chars)
static OFString accessionNumberPrefix;  // AccessionNumber is SH (maximum 16 chars)
static OFString patientIDPrefix("PID_"); // PatientID is LO (maximum 64 chars)
static OFString patientNamePrefix("OFFIS^TEST_PN_");   // PatientName is PN (maximum 16 chars)

static OFCondition
addStoragePresentationContexts(T_ASC_Parameters *params, OFList<OFString>& sopClasses);
static OFCondition
cstore(T_ASC_Association * assoc, const OFString& fname);
static OFBool
isaListMember(OFList<OFString>& lst, OFString& s);

static OFCondition
addPresentationContext(T_ASC_Parameters *params,
int presentationContextId, const OFString& abstractSyntax,
const OFList<OFString>& transferSyntaxList,
T_ASC_SC_ROLE proposedRole = ASC_SC_ROLE_DEFAULT);
static OFCondition
addPresentationContext(T_ASC_Parameters *params,
int presentationContextId, const OFString& abstractSyntax,
const OFString& transferSyntax,
T_ASC_SC_ROLE proposedRole = ASC_SC_ROLE_DEFAULT);
static OFCondition
storeSCU(T_ASC_Association * assoc, const char *fname);
static void
replaceSOPInstanceInformation(DcmDataset* dataset);
static void
progressCallback(void * /*callbackData*/,
T_DIMSE_StoreProgress *progress,
T_DIMSE_C_StoreRQ * /*req*/);
static OFString
makeUID(OFString basePrefix, int counter);
static int
secondsSince1970();
static OFString
intToString(int i);
static OFBool
updateStringAttributeValue(DcmItem* dataset, const DcmTagKey& key, OFString& value);

BOOL APIENTRY DllMain( HANDLE hModule,
DWORD  ul_reason_for_call,
LPVOID lpReserved
)
{
return TRUE;
}

int IncInt(int params)
{
return params+1;
}

//int IniNet

/*==========================================================*/
//Created by hgb 20061229
//result value:
//0: success
//-1: not foud file
//-2:
//-3:
//-4:
//-5:
/*==========================================================*/
int __stdcall SendDCM(LPSTR ourTitle, LPSTR peerTitle,
LPSTR scpIP, LPSTR scpPort, LPSTR FileName)
{
char sopClassUID[128];
char sopInstanceUID[128];
OFList<OFString> fileNameList;
OFList<OFString> sopClassUIDList;
OFList<OFString> sopInstanceUIDList;
T_ASC_Network *net;
T_ASC_Parameters *params;
DIC_NODENAME localHost;
DIC_NODENAME peerHost;
T_ASC_Association *assoc;

//TCHAR tcsModulePath[_MAX_PATH];
//::GetModuleFileName(NULL, tcsModulePath, _MAX_PATH);

//CString strCurDir = tcsModulePath;
//strCurDir = strCurDir.Left(strCurDir.ReverseFind(TEXT('\\'))+1);
//char currentFilename[strCurDir.GetLength()+1];
//strcpy(currentFilename, strCurDir.GetBuffer());
//char *currentFilename = strCurDir;

#ifdef HAVE_GUSI_H
GUSISetup(GUSIwithSIOUXSockets);
GUSISetup(GUSIwithInternetSockets);
#endif

#ifdef HAVE_WINSOCK_H
WSAData winSockData;
/* we need at least version 1.1 */
WORD winSockVersionNeeded = MAKEWORD( 1, 1 );
WSAStartup(winSockVersionNeeded, &winSockData);
#endif

/*
CFileFind find;
if(find.FindFile(FileName))
{
return -1; // not found the file
}
*/

if (access(FileName, R_OK)!=0)
return -2; // did't access file
if (!DU_findSOPClassAndInstanceInFile(FileName, sopClassUID, sopInstanceUID))
return -101;
if (!dcmIsaStorageSOPClassUID(sopClassUID))
return -102;
else
{
//fileNameList.push_back(FileName);
sopClassUIDList.push_back(sopClassUID);
sopInstanceUIDList.push_back(sopInstanceUID);

OFCondition cond = ASC_initializeNetwork(NET_REQUESTOR, 0, 30, &net);
if (cond.bad())
return -103;

cond = ASC_createAssociationParameters(¶ms, ASC_DEFAULTMAXPDU);
if (cond.bad())
return -104;

ASC_setAPTitles(params, ourTitle, peerTitle, NULL);
gethostname(localHost, sizeof(localHost) - 1);
sprintf(peerHost, "%s:%s", scpIP, scpPort);////////
ASC_setPresentationAddresses(params, localHost, peerHost);

cond = addStoragePresentationContexts(params, sopClassUIDList);
if (cond.bad())
{
return -105;
}

cond = ASC_requestAssociation(net, params, &assoc);
if (cond.bad())
{
if (cond == DUL_ASSOCIATIONREJECTED) {
return -106;
} else {  //Association Request Failed
return -107;
}
}

//发送文件
cond = EC_Normal;
//OFListIterator(OFString) iter = fileNameList.begin();
//OFListIterator(OFString) enditer = fileNameList.end();////
//cond = cstore(assoc, *iter);  //OFString
cond = cstore(assoc, OFString(FileName));
if (cond != EC_Normal)
{
//ASC_releaseAssociation(assoc);
//ASC_destroyAssociation(&assoc);
//DimseCondition::dump(cond);
//#ifdef HAVE_WINSOCK_H
//WSACleanup();
//#endif
return -108;//send faid;
}

cond = ASC_releaseAssociation(assoc);
if (cond.bad())
return -109;

cond = ASC_destroyAssociation(&assoc);
if (cond.bad())
return -120;

}

#ifdef HAVE_WINSOCK_H
WSACleanup();
#endif
return 0;

}

static OFCondition
addStoragePresentationContexts(T_ASC_Parameters *params, OFList<OFString>& sopClasses)
{
/*
* Each SOP Class will be proposed in two presentation contexts (unless
* the opt_combineProposedTransferSyntaxes global variable is true).
* The command line specified a preferred transfer syntax to use.
* This prefered transfer syntax will be proposed in one
* presentation context and a set of alternative (fallback) transfer
* syntaxes will be proposed in a different presentation context.
*
* Generally, we prefer to use Explicitly encoded transfer syntaxes
* and if running on a Little Endian machine we prefer
* LittleEndianExplicitTransferSyntax to BigEndianTransferSyntax.
* Some SCP implementations will just select the first transfer
* syntax they support (this is not part of the standard) so
* organise the proposed transfer syntaxes to take advantage
* of such behaviour.
*/

// Which transfer syntax was preferred on the command line
OFString preferredTransferSyntax;
if (opt_networkTransferSyntax == EXS_Unknown) {
/* gLocalByteOrder is defined in dcxfer.h */
if (gLocalByteOrder == EBO_LittleEndian) {
/* we are on a little endian machine */
preferredTransferSyntax = UID_LittleEndianExplicitTransferSyntax;
} else {
/* we are on a big endian machine */
preferredTransferSyntax = UID_BigEndianExplicitTransferSyntax;
}
} else {
DcmXfer xfer(opt_networkTransferSyntax);
preferredTransferSyntax = xfer.getXferID();
}

OFListIterator(OFString) s_cur;
OFListIterator(OFString) s_end;

OFList<OFString> fallbackSyntaxes;
fallbackSyntaxes.push_back(UID_LittleEndianExplicitTransferSyntax);
fallbackSyntaxes.push_back(UID_BigEndianExplicitTransferSyntax);
fallbackSyntaxes.push_back(UID_LittleEndianImplicitTransferSyntax);
// Remove the preferred syntax from the fallback list
fallbackSyntaxes.remove(preferredTransferSyntax);
// If little endian implicit is preferred then we don't need any fallback syntaxes
// because it is the default transfer syntax and all applications must support it.
if (opt_networkTransferSyntax == EXS_LittleEndianImplicit) {
fallbackSyntaxes.clear();
}

// created a list of transfer syntaxes combined from the preferred and fallback syntaxes
OFList<OFString> combinedSyntaxes;
s_cur = fallbackSyntaxes.begin();
s_end = fallbackSyntaxes.end();
combinedSyntaxes.push_back(preferredTransferSyntax);
while (s_cur != s_end)
{
if (!isaListMember(combinedSyntaxes, *s_cur)) combinedSyntaxes.push_back(*s_cur);
++s_cur;
}

if (!opt_proposeOnlyRequiredPresentationContexts) {
// add the (short list of) known storage sop classes to the list
// the array of Storage SOP Class UIDs comes from dcuid.h
for (int i=0; i<numberOfDcmShortSCUStorageSOPClassUIDs; i++) {
sopClasses.push_back(dcmShortSCUStorageSOPClassUIDs[i]);
}
}

// thin out the sop classes to remove any duplicates.
OFList<OFString> sops;
s_cur = sopClasses.begin();
s_end = sopClasses.end();
while (s_cur != s_end) {
if (!isaListMember(sops, *s_cur)) {
sops.push_back(*s_cur);
}
++s_cur;
}

// add a presentations context for each sop class / transfer syntax pair
OFCondition cond = EC_Normal;
int pid = 1; // presentation context id
s_cur = sops.begin();
s_end = sops.end();
while (s_cur != s_end && cond.good()) {

if (pid > 255) {
///errmsg("Too many presentation contexts");
return ASC_BADPRESENTATIONCONTEXTID;
}

if (opt_combineProposedTransferSyntaxes) {
cond = addPresentationContext(params, pid, *s_cur, combinedSyntaxes);
pid += 2;   /* only odd presentation context id's */
} else {

// sop class with preferred transfer syntax
cond = addPresentationContext(params, pid, *s_cur, preferredTransferSyntax);
pid += 2;   /* only odd presentation context id's */

if (fallbackSyntaxes.size() > 0) {
if (pid > 255) {
//errmsg("Too many presentation contexts");
return ASC_BADPRESENTATIONCONTEXTID;
}

// sop class with fallback transfer syntax
cond = addPresentationContext(params, pid, *s_cur, fallbackSyntaxes);
pid += 2;       /* only odd presentation context id's */
}
}
++s_cur;
}

return cond;
}

static OFCondition
cstore(T_ASC_Association * assoc, const OFString& fname)
/*
* This function will process the given file as often as is specified by opt_repeatCount.
* "Process" in this case means "read file, send C-STORE-RQ, receive C-STORE-RSP".
*
* Parameters:
*   assoc - [in] The association (network connection to another DICOM application).
*   fname - [in] Name of the file which shall be processed.
*/
{
OFCondition cond = EC_Normal;

/* opt_repeatCount specifies how many times a certain file shall be processed */
int n = (int)opt_repeatCount;

/* as long as no error occured and the counter does not equal 0 */
while ((cond.good()) && n-- && !(opt_haltOnUnsuccessfulStore && unsuccessfulStoreEncountered))
{
/* process file (read file, send C-STORE-RQ, receive C-STORE-RSP) */
cond = storeSCU(assoc, fname.c_str());
}

// we don't want to return an error code if --no-halt was specified.
if (! opt_haltOnUnsuccessfulStore)
{
cond = EC_Normal;
}

/* return result value */
return cond;
}

static OFBool
isaListMember(OFList<OFString>& lst, OFString& s)
{
OFListIterator(OFString) cur = lst.begin();
OFListIterator(OFString) end = lst.end();

OFBool found = OFFalse;

while (cur != end && !found) {

found = (s == *cur);

++cur;
}

return found;
}

static OFCondition
addPresentationContext(T_ASC_Parameters *params,
int presentationContextId, const OFString& abstractSyntax,
const OFString& transferSyntax,
T_ASC_SC_ROLE proposedRole)
{
const char* c_p = transferSyntax.c_str();
OFCondition cond = ASC_addPresentationContext(params, presentationContextId,
abstractSyntax.c_str(), &c_p, 1, proposedRole);
return cond;
}

static OFCondition
addPresentationContext(T_ASC_Parameters *params,
int presentationContextId, const OFString& abstractSyntax,
const OFList<OFString>& transferSyntaxList,
T_ASC_SC_ROLE proposedRole)
{
// create an array of supported/possible transfer syntaxes
const char** transferSyntaxes = new const char*[transferSyntaxList.size()];
int transferSyntaxCount = 0;
OFListConstIterator(OFString) s_cur = transferSyntaxList.begin();
OFListConstIterator(OFString) s_end = transferSyntaxList.end();
while (s_cur != s_end) {
transferSyntaxes[transferSyntaxCount++] = (*s_cur).c_str();
++s_cur;
}

OFCondition cond = ASC_addPresentationContext(params, presentationContextId,
abstractSyntax.c_str(), transferSyntaxes, transferSyntaxCount, proposedRole);

delete[] transferSyntaxes;
return cond;
}

static OFCondition
storeSCU(T_ASC_Association * assoc, const char *fname)
/*
* This function will read all the information from the given file,
* figure out a corresponding presentation context which will be used
* to transmit the information over the network to the SCP, and it
* will finally initiate the transmission of all data to the SCP.
*
* Parameters:
*   assoc - [in] The association (network connection to another DICOM application).
*   fname - [in] Name of the file which shall be processed.
*/
{
DIC_US msgId = assoc->nextMsgID++;
T_ASC_PresentationContextID presId;
T_DIMSE_C_StoreRQ req;
T_DIMSE_C_StoreRSP rsp;
DIC_UI sopClass;
DIC_UI sopInstance;
DcmDataset *statusDetail = NULL;

unsuccessfulStoreEncountered = OFTrue; // assumption

if (opt_verbose) {
printf("--------------------------\n");
printf("Sending file: %s\n", fname);
}

/* read information from file. After the call to DcmFileFormat::loadFile(...) the information */
/* which is encapsulated in the file will be available through the DcmFileFormat object. */
/* In detail, it will be available through calls to DcmFileFormat::getMetaInfo() (for */
/* meta header information) and DcmFileFormat::getDataset() (for data set information). */
DcmFileFormat dcmff;
OFCondition cond = dcmff.loadFile(fname);

/* figure out if an error occured while the file was read*/
if (cond.bad()) {
//errmsg("Bad DICOM file: %s: %s", fname, cond.text());
return cond;
}

/* if required, invent new SOP instance information for the current data set (user option) */
if (opt_inventSOPInstanceInformation) {
replaceSOPInstanceInformation(dcmff.getDataset());
}

/* figure out which SOP class and SOP instance is encapsulated in the file */
if (!DU_findSOPClassAndInstanceInDataSet(dcmff.getDataset(),
sopClass, sopInstance, opt_correctUIDPadding)) {
//errmsg("No SOP Class & Instance UIDs in file: %s", fname);
return DIMSE_BADDATA;
}

/* figure out which of the accepted presentation contexts should be used */
DcmXfer filexfer(dcmff.getDataset()->getOriginalXfer());//??????? added by HGB

/* special case: if the file uses an unencapsulated transfer syntax (uncompressed
* or deflated explicit VR) and we prefer deflated explicit VR, then try
* to find a presentation context for deflated explicit VR first.
*/
if (filexfer.isNotEncapsulated() &&
opt_networkTransferSyntax == EXS_DeflatedLittleEndianExplicit)
{
filexfer = EXS_DeflatedLittleEndianExplicit;
}

if (filexfer.getXfer() != EXS_Unknown) presId = ASC_findAcceptedPresentationContextID(assoc, sopClass, filexfer.getXferID());
else presId = ASC_findAcceptedPresentationContextID(assoc, sopClass);
if (presId == 0) {
const char *modalityName = dcmSOPClassUIDToModality(sopClass);
if (!modalityName) modalityName = dcmFindNameOfUID(sopClass);
if (!modalityName) modalityName = "unknown SOP class";
// errmsg("No presentation context for: (%s) %s", modalityName, sopClass);
return DIMSE_NOVALIDPRESENTATIONCONTEXTID;
}

/* if required, dump general information concerning transfer syntaxes */
if (opt_verbose) {
DcmXfer fileTransfer(dcmff.getDataset()->getOriginalXfer());
T_ASC_PresentationContext pc;
ASC_findAcceptedPresentationContext(assoc->params, presId, &pc);
DcmXfer netTransfer(pc.acceptedTransferSyntax);
printf("Transfer: %s -> %s\n",
dcmFindNameOfUID(fileTransfer.getXferID()), dcmFindNameOfUID(netTransfer.getXferID()));
}

/* prepare the transmission of data */
bzero((char*)&req, sizeof(req));
req.MessageID = msgId;
strcpy(req.AffectedSOPClassUID, sopClass);
strcpy(req.AffectedSOPInstanceUID, sopInstance);
req.DataSetType = DIMSE_DATASET_PRESENT;
req.Priority = DIMSE_PRIORITY_LOW;

/* if required, dump some more general information */
if (opt_verbose) {
printf("Store SCU RQ: MsgID %d, (%s)\n", msgId, dcmSOPClassUIDToModality(sopClass));
}

/* finally conduct transmission of data */
cond = DIMSE_storeUser(assoc, presId, &req,
NULL, dcmff.getDataset(), progressCallback, NULL,
opt_blockMode, opt_dimse_timeout,
&rsp, &statusDetail, NULL, DU_fileSize(fname));

/*
* If store command completed normally, with a status
* of success or some warning then the image was accepted.
*/
if (cond == EC_Normal && (rsp.DimseStatus == STATUS_Success || DICOM_WARNING_STATUS(rsp.DimseStatus))) {
unsuccessfulStoreEncountered = OFFalse;
}

/* remember the response's status for later transmissions of data */
lastStatusCode = rsp.DimseStatus;

/* dump some more general information */
if (cond == EC_Normal)
{
if (opt_verbose) {
DIMSE_printCStoreRSP(stdout, &rsp);
}
}
else
{
//errmsg("Store Failed, file: %s:", fname);
DimseCondition::dump(cond);
}

/* dump status detail information if there is some */
if (statusDetail != NULL) {
printf("  Status Detail:\n");
statusDetail->print(COUT);
delete statusDetail;
}
/* return */
return cond;
}

static void
replaceSOPInstanceInformation(DcmDataset* dataset)
{
static OFCmdUnsignedInt patientCounter = 0;
static OFCmdUnsignedInt studyCounter = 0;
static OFCmdUnsignedInt seriesCounter = 0;
static OFCmdUnsignedInt imageCounter = 0;
static OFString seriesInstanceUID;
static OFString seriesNumber;
static OFString studyInstanceUID;
static OFString studyID;
static OFString accessionNumber;
static OFString patientID;
static OFString patientName;

if (seriesInstanceUID.length() == 0) seriesInstanceUID=makeUID(SITE_SERIES_UID_ROOT, (int)seriesCounter);
if (seriesNumber.length() == 0) seriesNumber = intToString((int)seriesCounter);
if (studyInstanceUID.length() == 0) studyInstanceUID = makeUID(SITE_STUDY_UID_ROOT, (int)studyCounter);
if (studyID.length() == 0) studyID = studyIDPrefix + intToString((int)secondsSince1970()) + intToString((int)studyCounter);
if (accessionNumber.length() == 0) accessionNumber = accessionNumberPrefix + intToString(secondsSince1970()) + intToString((int)studyCounter);
if (patientID.length() == 0) patientID = patientIDPrefix + intToString(secondsSince1970()) + intToString((int)patientCounter);
if (patientName.length() == 0) patientName = patientNamePrefix + intToString(secondsSince1970()) + intToString((int)patientCounter);

if (imageCounter >= opt_inventSeriesCount) {
imageCounter = 0;
seriesCounter++;
seriesInstanceUID = makeUID(SITE_SERIES_UID_ROOT, (int)seriesCounter);
seriesNumber = intToString((int)seriesCounter);
}
if (seriesCounter >= opt_inventStudyCount) {
seriesCounter = 0;
studyCounter++;
studyInstanceUID = makeUID(SITE_STUDY_UID_ROOT, (int)studyCounter);
studyID = studyIDPrefix + intToString(secondsSince1970()) + intToString((int)studyCounter);
accessionNumber = accessionNumberPrefix + intToString(secondsSince1970()) + intToString((int)studyCounter);
}
if (studyCounter >= opt_inventPatientCount) {
// we create as many patients as necessary */
studyCounter = 0;
patientCounter++;
patientID = patientIDPrefix + intToString(secondsSince1970()) + intToString((int)patientCounter);
patientName = patientNamePrefix + intToString(secondsSince1970()) + intToString((int)patientCounter);
}

OFString sopInstanceUID = makeUID(SITE_INSTANCE_UID_ROOT, (int)imageCounter);
OFString imageNumber = intToString((int)imageCounter);

if (opt_verbose) {
COUT << "Inventing Identifying Information (" <<
"pa" << patientCounter << ", st" << studyCounter <<
", se" << seriesCounter << ", im" << imageCounter << "): " << endl;
COUT << "  PatientName=" << patientName << endl;
COUT << "  PatientID=" << patientID << endl;
COUT << "  StudyInstanceUID=" << studyInstanceUID << endl;
COUT << "  StudyID=" << studyID << endl;
COUT << "  SeriesInstanceUID=" << seriesInstanceUID << endl;
COUT << "  SeriesNumber=" << seriesNumber << endl;
COUT << "  SOPInstanceUID=" << sopInstanceUID << endl;
COUT << "  ImageNumber=" << imageNumber << endl;
}

updateStringAttributeValue(dataset, DCM_PatientsName, patientName);
updateStringAttributeValue(dataset, DCM_PatientID, patientID);
updateStringAttributeValue(dataset, DCM_StudyInstanceUID, studyInstanceUID);
updateStringAttributeValue(dataset, DCM_StudyID, studyID);
updateStringAttributeValue(dataset, DCM_SeriesInstanceUID, seriesInstanceUID);
updateStringAttributeValue(dataset, DCM_SeriesNumber, seriesNumber);
updateStringAttributeValue(dataset, DCM_SOPInstanceUID, sopInstanceUID);
updateStringAttributeValue(dataset, DCM_InstanceNumber, imageNumber);

imageCounter++;
}

static void
progressCallback(void * /*callbackData*/,
T_DIMSE_StoreProgress *progress,
T_DIMSE_C_StoreRQ * /*req*/)
{
if (opt_verbose) {
switch (progress->state) {
case DIMSE_StoreBegin:
printf("XMIT:"); break;
case DIMSE_StoreEnd:
printf("\n"); break;
default:
putchar('.'); break;
}
fflush(stdout);
}
}

static OFString
makeUID(OFString basePrefix, int counter)
{
OFString prefix = basePrefix + "." + intToString(counter);
char uidbuf[65];
OFString uid = dcmGenerateUniqueIdentifier(uidbuf, prefix.c_str());
return uid;
}

static int
secondsSince1970()
{
time_t t = time(NULL);
return (int)t;
}

static OFString
intToString(int i)
{
char numbuf[32];
sprintf(numbuf, "%d", i);
return numbuf;
}

static OFBool
updateStringAttributeValue(DcmItem* dataset, const DcmTagKey& key, OFString& value)
{
DcmStack stack;
DcmTag tag(key);

OFCondition cond = EC_Normal;
cond = dataset->search(key, stack, ESM_fromHere, OFFalse);
if (cond != EC_Normal) {
CERR << "error: updateStringAttributeValue: cannot find: " << tag.getTagName()
<< " " << key << ": "
<< cond.text() << endl;
return OFFalse;
}

DcmElement* elem = (DcmElement*) stack.top();

DcmVR vr(elem->ident());
if (elem->getLength() > vr.getMaxValueLength()) {
CERR << "error: updateStringAttributeValue: INTERNAL ERROR: " << tag.getTagName()
<< " " << key << ": value too large (max "
<< vr.getMaxValueLength() << ") for " << vr.getVRName() << " value: " << value << endl;
return OFFalse;
}

cond = elem->putOFStringArray(value);
if (cond != EC_Normal) {
CERR << "error: updateStringAttributeValue: cannot put string in attribute: " << tag.getTagName()
<< " " << key << ": "
<< cond.text() << endl;
return OFFalse;
}

return OFTrue;
}