int authinteract(auth_client_request_t request, char ** result, int fields, void * arg)
{
long i;
auth_data_struct_t *dupa=(auth_data_struct_t *)arg;
if (!(dupa != NULL))
{
PRINT_ERROR("auth_data_struct_t variable is NULL!\n");
abort();
}
if (!(fields == 2))
{
PRINT_ERROR("There should be exactly 2 fields!\n");
abort();
}
PRINT_VDEBUG("auth interacting function\n");
for (i = 0; i < fields; i++) {
PRINT_VDEBUG("%s\n",request[i].prompt);
if (request[i].flags & AUTH_PASS)
{
result[i] = dupa->password;
// odwrócona kolejność powodowała wpisywanie hasła w miejsce użytkownika i na odwrót - w skutek czego nie działało wysyłanie z autoryzacją - RO
// tylko wskazuję na miejsce przechowywania hasła - nie ma potrzeby go duplikować, bo i tak nie ma jak później tego zwolnić - RO
}
else
{
result[i] = dupa->username;
}
}
PRINT_VDEBUG("End of auth interacting function\n");
return 1;
}
uint64_t cRosClockGetTimeMs()
{
PRINT_VDEBUG ( "cRosClockGetTimeMs()\n" );
struct timeval tv;
gettimeofday( &tv, NULL );
return (uint64_t)tv.tv_sec*1000 + (uint64_t)tv.tv_usec/1000;
}
/*wynik trzeba zwalniac, bo jest dynamicznie alokowany*/
char* bmdconf_get_value_config(struct bmdconf_mem_list **list_name,char *section_name,char *option_name)
{
char *temp1,*temp2;
PRINT_VDEBUG("BMDCONFIGINF Getting configuration value %s in section %s\n",option_name, section_name);
temp1=bmdconf_find_list_item(list_name,section_name,option_name);
if(temp1!=NULL)
{
temp2=(char*)malloc( (strlen(temp1)+1)*sizeof(char) );
strcpy(temp2,temp1);
return temp2;
}
return NULL;
}
struct timeval cRosClockGetTimeVal( uint64_t msec )
{
PRINT_VDEBUG ( "cRosClockGetTimeVal()\n" );
struct timeval tv;
if (msec > ( LONG_MAX * 1000ULL ))
{
// Given timespan would overflow timeval
tv.tv_sec = LONG_MAX;
tv.tv_usec = 999999L;
}
else
{
tv.tv_sec = (long)(msec / 1000);
tv.tv_usec = (long)(msec - tv.tv_sec * 1000ULL ) * 1000;
}
return tv;
}
/**Funkcja sprawdza, czy certyfikat jest ważny w danym momencie oznaczonym przez timestamp.
* \param certyfikat Certyfikat do sprawdzenia.
* \param timestamp Znacznik czasu.
* */
long isCertificateValid(GenBuf_t **certyfikat, GenBuf_t *timestamp)
{
long status = -1;
char *validNB = NULL;/*początek okresu wazności*/
char *validNA = NULL;/*koniec okresu ważności*/
char *today = NULL;/*dzisiejsza data*/
GenBuf_t *PlainData = NULL;
time_t tNB, tNA, tToday;
if (certyfikat == NULL || *certyfikat == NULL)
{
PRINT_DEBUG("Wrong argument 1\n");
return ERR_arg+1;
}
if (timestamp == NULL)
{
PRINT_DEBUG("Wrong argument 2\n");
return ERR_arg+2;
}
/*poczatek waznosci*/
status = GetValidityNBFromX509Certificate_time(*certyfikat, &tNB);
if (status < 0)
{
PRINT_DEBUG("Couldn't get validity not before\n");
return -1;
}
/*koniec waznosci*/
status = GetValidityNAFromX509Certificate_time(*certyfikat, &tNA);
if (status < 0)
{
PRINT_DEBUG("Couldn't get validity not after\n");
return -2;
}
PRINT_VDEBUG("Getting current date from timestamp...\n");
status = GetGenerationTimeFromTimestamp_time(timestamp, &tToday);
if (status < 0)
{
PRINT_DEBUG("Couldn't get current date and time\n");
return -3;
}
/*ewentualne wydruki*/
/*PRINT_VDEBUG("Valid not before: %s\n", validNB);
PRINT_VDEBUG("Valid not after: %s\n", validNA);
PRINT_VDEBUG("Today is: %s\n", today);*/
/*konieczne porównania*/
/*tNB = _to_seconds(validNB);
tNA = _to_seconds(validNA);
tToday = _to_seconds(today);*/
if (tToday < tNB)
{
PRINT_DEBUG("Certificate not valid before %s!\n", validNB);
return -4;
}
else if (tToday > tNA)
{
PRINT_DEBUG("Certificate not valid after %s!\n", validNA);
return -5;
}
free(validNB);
free(validNA);
free(today);
free_gen_buf(&PlainData);
return 0;
}
/**
* Funkcja porównuje zawartość pól X509IssuerName, X509SerialNumber i CertDigest
* w certyfikacie i w formularzu.
* \retval -1 Nie można przeparsować dokumentu.
* \retval -2 Nie można pobrać info certyfikatu z formularza.
* \retval -3 Nie można pobrać info z formularza.
* \retval -4 Niezgodne numery seryjne.
* \retval -5 Niezgodne nazwy wystawców.
* \retval -6 Nie można utworzyć skrótu z certyfikatu.
* \retval -7 Nie można pobrać skrótu certyfikatu z formularza.
* \retval -8 Niezgodne skróty z certyfikatów.
* \retval -9 Certyfikat przeterminowany.
* */
long verify_fields(const char *buffer, const long buffer_len, GenBuf_t *timestamp)
{
xmlDocPtr document = NULL;
char *CertSerialNumber = NULL; /*serial sczytany z certyfikatu*/
char *FormSerialNumber = NULL; /*serial sczytany z formularza*/
char *CertIssuerName = NULL; /*wystawca sczytany z certyfikatu*/
char *FormIssuerName = NULL; /*wystawca sczytany z formularza*/
char *CertDigest = NULL; /*digest w base64 do porównania*/
char *FormDigest = NULL; /*digest z formularza*/
GenBuf_t *certyfikat = NULL; /*genbuf z certyfikatem*/
LIBBMDXADES_DIGEST_METHOD_t metoda;
long status;
/*kontrola poprawnosci parametrow*/
if (buffer == NULL)
{
PRINT_DEBUG("Wrong argument 1\n");
return ERR_arg+1;
}
if (buffer_len == 0)
{
PRINT_DEBUG("Wrong argument 2 (too short!)\n");
return ERR_arg+2;
}
/* load file */
document = xmlParseMemory(buffer,buffer_len);
if ((document == NULL) || (xmlDocGetRootElement(document) == NULL))
{
PRINT_DEBUG("UNABLE TO PARSE DOCUMENT\n");
return -1;
}
/* pobieramy certyfikat*/
status = _getCertificateFromXML(&document, &certyfikat);
if (status < 0)
{
PRINT_DEBUG("Error while getting certificate.\n");
return -2;
}
/*pobieramy date waznosci*/
status = isCertificateValid(&certyfikat, timestamp);
if (status < 0)
{
PRINT_DEBUG("Error - certificate not valid!\n");
return -9;
}
/* get Serial and IssuerName from certificate in the form*/
status = _getInfoFromCertificate(&certyfikat, &CertSerialNumber, &CertIssuerName);
if (status < 0)
{
PRINT_DEBUG("Error while getting info from X509 Certificate.\n");
return -2;
}
PRINT_VDEBUG("Form signed by certificate issued by %s, serial: %s\n",
CertIssuerName, CertSerialNumber);
/* get Serial and IssuerName from the form*/
_getInfoFromXML(&document, &FormSerialNumber, &FormIssuerName);
if (status < 0)
{
PRINT_DEBUG("Error while getting info from the form.\n");
return -3;
}
/*porównujemy seriale*/
status = _compareSerials(&CertSerialNumber, &FormSerialNumber);
if (status != 0)
{
PRINT_DEBUG("Bad serial number.\n");
return -4;
}
/*porównujemy wystawcow*/
status = _compareIssuerNames(&CertIssuerName, &FormIssuerName);
if (status != 0)
{
PRINT_DEBUG("Bad issuer name.\n");
return -5;
}
/*sprawdzamy digest*/
status = _getDigestAndMethod(&document, &FormDigest, &metoda);
if (status < 0)
{
PRINT_DEBUG("Cannot get digests from XML!\n");
return -7;
}
_getCertificateDigest(&certyfikat, metoda, &CertDigest);
if (status < 0)
{
PRINT_DEBUG("Error while digesting certificate!\n");
return -6;
}
if (strcmp(FormDigest, CertDigest)!= 0)
{
PRINT_DEBUG("Digests in cert and XML vary!\n");
return -8;
}
/*sprzatamy*/
free(CertIssuerName);
free(CertSerialNumber);
free(FormIssuerName);
free(FormSerialNumber);
free(CertDigest);
free(FormDigest);
free_gen_buf(&certyfikat);
xmlFreeDoc(document);
return 0;
}
long _PR_bmdDatagram_free( bmdDatagram_t *bmdDatagram,
long with_pointer)
{
long i = 0;
if(bmdDatagram == NULL)
{
PRINT_WARNING("LIBBMDPRWARN Nothing to be freed.\n");
return BMD_OK;
}
if(bmdDatagram->actionMetaData != NULL)
{
for(i=0; i<bmdDatagram->no_of_actionMetaData; i++)
{
PRINT_VDEBUG("LIBBMDPRVDEBUG Free actionMetaData loop iterations: %li\n", i);
if(bmdDatagram->actionMetaData[i] != NULL)
{
free(bmdDatagram->actionMetaData[i]->OIDTableBuf);
bmdDatagram->actionMetaData[i]->OIDTableBuf = NULL;
free(bmdDatagram->actionMetaData[i]->AnyBuf);
bmdDatagram->actionMetaData[i]->AnyBuf = NULL;
free(bmdDatagram->actionMetaData[i]);
bmdDatagram->actionMetaData[i] = NULL;
}
}
free(bmdDatagram->actionMetaData);
bmdDatagram->actionMetaData = NULL;
}
if(bmdDatagram->sysMetaData != NULL)
{
for(i=0; i<bmdDatagram->no_of_sysMetaData; i++)
{
/* MSILEWICZ - wykomentowalem dla lepszej czytelnosci logow */
//PRINT_VDEBUG("LIBBMDPRVDEBUG Free sysMetaData loop iterations: %li\n", i);
if(bmdDatagram->sysMetaData[i] != NULL)
{
free(bmdDatagram->sysMetaData[i]->OIDTableBuf);
bmdDatagram->sysMetaData[i]->OIDTableBuf = NULL;
free(bmdDatagram->sysMetaData[i]->AnyBuf);
bmdDatagram->sysMetaData[i]->AnyBuf = NULL;
free(bmdDatagram->sysMetaData[i]);
bmdDatagram->sysMetaData[i] = NULL;
}
}
free(bmdDatagram->sysMetaData);
bmdDatagram->sysMetaData = NULL;
}
if(bmdDatagram->pkiMetaData != NULL)
{
for(i=0; i<bmdDatagram->no_of_pkiMetaData; i++)
{
PRINT_VDEBUG("LIBBMDPRVDEBUG Free pkiMetaData loop iterations: %li\n", i);
if(bmdDatagram->pkiMetaData[i] != NULL)
{
free(bmdDatagram->pkiMetaData[i]->OIDTableBuf);
bmdDatagram->pkiMetaData[i]->OIDTableBuf = NULL;
free(bmdDatagram->pkiMetaData[i]->AnyBuf);
bmdDatagram->pkiMetaData[i]->AnyBuf = NULL;
free(bmdDatagram->pkiMetaData[i]);
bmdDatagram->pkiMetaData[i] = NULL;
}
}
free(bmdDatagram->pkiMetaData);
bmdDatagram->pkiMetaData = NULL;
}
if(bmdDatagram->additionalMetaData != NULL)
{
free(bmdDatagram->additionalMetaData_string);
bmdDatagram->additionalMetaData_string = NULL;
free(bmdDatagram->additionalMetaData_string_len);
bmdDatagram->additionalMetaData_string_len = NULL;
PRINT_VDEBUG("LIBBMDPRVDEBUG additionalMetaData_string_count %li\n",
bmdDatagram->additionalMetaData_string_count);
for(i=0; i<bmdDatagram->additionalMetaData_string_count; i++)
{
//PRINT_VDEBUG("LIBBMDPRVDEBUG Free additionalMetaData loop iterations: %li\n", i);
if(bmdDatagram->additionalMetaData[i] != NULL)
{
free(bmdDatagram->additionalMetaData[i]->OIDTableBuf);
bmdDatagram->additionalMetaData[i]->OIDTableBuf = NULL;
/*free(bmdDatagram->additionalMetaData[i]->AnyBuf);*/
bmdDatagram->additionalMetaData[i]->AnyBuf = NULL;
free(bmdDatagram->additionalMetaData[i]);
bmdDatagram->additionalMetaData[i] = NULL;
}
}
for(i=bmdDatagram->additionalMetaData_string_count; i<bmdDatagram->no_of_additionalMetaData; i++)
{
//PRINT_VDEBUG("LIBBMDPRVDEBUG Free additionalMetaData loop iterations: %li\n", i);
if(bmdDatagram->additionalMetaData[i] != NULL)
{
free(bmdDatagram->additionalMetaData[i]->OIDTableBuf);
bmdDatagram->additionalMetaData[i]->OIDTableBuf = NULL;
free(bmdDatagram->additionalMetaData[i]->AnyBuf);
bmdDatagram->additionalMetaData[i]->AnyBuf = NULL;
free(bmdDatagram->additionalMetaData[i]);
bmdDatagram->additionalMetaData[i] = NULL;
}
}
free(bmdDatagram->additionalMetaData);
bmdDatagram->additionalMetaData = NULL;
}
if(bmdDatagram->protocolData != NULL)
{
if(bmdDatagram->protocolData->buf != NULL)
{
free(bmdDatagram->protocolData->buf);
bmdDatagram->protocolData->buf = NULL;
}
free(bmdDatagram->protocolData);
bmdDatagram->protocolData = NULL;
}
if(bmdDatagram->protocolDataFilename != NULL)
{
if (bmdDatagram->protocolDataFilename->buf!=NULL)
{
free(bmdDatagram->protocolDataFilename->buf);
bmdDatagram->protocolDataFilename->buf = NULL;
}
free(bmdDatagram->protocolDataFilename);
bmdDatagram->protocolDataFilename = NULL;
}
if(bmdDatagram->protocolDataFileLocationId != NULL)
{
if (bmdDatagram->protocolDataFileLocationId->buf!=NULL)
{
free(bmdDatagram->protocolDataFileLocationId->buf);
bmdDatagram->protocolDataFileLocationId->buf = NULL;
}
free(bmdDatagram->protocolDataFileLocationId);
bmdDatagram->protocolDataFileLocationId = NULL;
}
if(bmdDatagram->protocolDataFileId != NULL)
{
free(bmdDatagram->protocolDataFileId);
bmdDatagram->protocolDataFileId = NULL;
}
if(bmdDatagram->protocolDataOwner != NULL)
{
if (bmdDatagram->protocolDataOwner->buf!=NULL)
{
free(bmdDatagram->protocolDataOwner->buf);
bmdDatagram->protocolDataOwner->buf = NULL;
}
free(bmdDatagram->protocolDataOwner);
bmdDatagram->protocolDataOwner = NULL;
}
if(with_pointer)
{
free(bmdDatagram);
bmdDatagram = NULL;
}
return BMD_OK;
}
long _PR_MetaData2MetaDataBuf(struct MetaDatas *input,
MetaDataBuf_t ***mtds,
long *no_of_mtds,
bmdDatagram_t *twf_bmdDatagram)
{
long i = 0;
long pos = 0;
char *OIDs_str = NULL;
char *myIds_str = NULL;
char *ownerIds_str = NULL;
char *ownerTypes_str = NULL;
char *datas_str = NULL;
char *str_pos = NULL;
/************************/
/* walidacja parametrow */
/************************/
if(mtds == NULL) { BMD_FOK(BMD_ERR_PARAM2); }
if((*mtds)!= NULL) { BMD_FOK(BMD_ERR_PARAM2); }
if(no_of_mtds == NULL) { BMD_FOK(BMD_ERR_PARAM3); }
if(input==NULL)
{
*no_of_mtds=0;
*mtds=NULL;
return BMD_OK;
}
/**************************************************************/
/* określenie liczby metadanych i zaalokowanie pamięci na nie */
/**************************************************************/
(*no_of_mtds)=input->lenOfDatas.list.count;
PRINT_VDEBUG("LIBBMDPRVDEBUG Metadatas count: %li\n", *no_of_mtds);
(*mtds)=(MetaDataBuf_t **)malloc(sizeof(MetaDataBuf_t *)*( (*no_of_mtds)));
if( (*mtds) == NULL ) { BMD_FOK(NO_MEMORY); }
memset((*mtds),0,sizeof(MetaDataBuf_t *)*( (*no_of_mtds)));
for (i=0; i<(*no_of_mtds); i++)
{
(*mtds)[i]=(MetaDataBuf_t *)malloc(sizeof(MetaDataBuf_t ));
memset((*mtds)[i], 0, sizeof(MetaDataBuf_t ));
}
/***********************************/
/* deserializacja oidów metadanych */
/***********************************/
BMD_FOK(OCTET_STRING2string(&(input->oids), &OIDs_str));
pos = 0;
str_pos = OIDs_str;
for(i=0; i < (*no_of_mtds); i++)
{
str_pos = str_pos + pos;
BMD_FOK(asn_INTEGER2long(input->lenOfOids.list.array[i], &pos));
((*mtds)[i])->OIDTableBuf=malloc((pos+1)*sizeof(char));
if (((*mtds)[i])->OIDTableBuf==NULL) { BMD_FOK(NO_MEMORY); }
memset(((*mtds)[i])->OIDTableBuf, 0, (pos+1)*sizeof(char));
memcpy(((*mtds)[i])->OIDTableBuf, str_pos, pos*sizeof(char));
pos++; /*Na NULL*/
}
free(OIDs_str); OIDs_str = NULL;
/**********************************/
/* deserializacja myId metadanych */
/**********************************/
BMD_FOK(OCTET_STRING2string(&(input->myIds), &myIds_str));
pos = 0;
str_pos = myIds_str;
for(i=0; i < *no_of_mtds; i++)
{
str_pos = str_pos + pos;
((*mtds)[i])->myId = atol(str_pos);
BMD_FOK(asn_INTEGER2long(input->lenOfMyIds.list.array[i], &pos));
pos++; /*Na NULL*/
}
free(myIds_str); myIds_str = NULL;
/*************************************/
/* deserializacja ownerId metadanych */
/*************************************/
BMD_FOK(OCTET_STRING2string(&(input->ownerIds), &ownerIds_str));
pos = 0;
str_pos = ownerIds_str;
for(i=0; i < *no_of_mtds; i++)
{
str_pos = str_pos + pos;
((*mtds)[i])->ownerId = atol(str_pos);
BMD_FOK(asn_INTEGER2long(input->lenOfOwnerIds.list.array[i], &pos));
pos++; /*Na NULL*/
}
free(ownerIds_str); ownerIds_str = NULL;
/***************************************/
/* deserializacja ownerType metadanych */
/***************************************/
BMD_FOK(OCTET_STRING2string(&(input->ownerTypes), &ownerTypes_str));
pos = 0;
str_pos = ownerTypes_str;
for(i=0; i < *no_of_mtds; i++)
{
str_pos = str_pos + pos;
((*mtds)[i])->ownerType = atol(str_pos);
BMD_FOK(asn_INTEGER2long(input->lenOfOwnerTypes.list.array[i], &pos));
pos++; /*Na NULL*/
}
free(ownerTypes_str); ownerTypes_str = NULL;
/**************************************/
/* deserializacja wartości metadanych */
/**************************************/
BMD_FOK(OCTET_STRING2string(&(input->datas), &datas_str));
pos = 0;
str_pos = datas_str;
if(twf_bmdDatagram != NULL)
{
str_pos = str_pos + pos;
BMD_FOK(asn_INTEGER2long(input->lenOfDatas.list.array[i], &pos));
((*mtds)[i])->AnyBuf = malloc((pos + 1) * sizeof(char));
if(((*mtds)[i])->AnyBuf == NULL) { BMD_FOK(NO_MEMORY); }
memset( ((*mtds)[i])->AnyBuf, 0, (pos + 1) * sizeof(char));
memcpy( ((*mtds)[i])->AnyBuf, str_pos, pos * sizeof(char));
((*mtds)[i])->AnySize = pos;
pos++; /*Na NULL*/
}
else
{
for(i=0; i < *no_of_mtds; i++)
{
str_pos = str_pos + pos;
BMD_FOK(asn_INTEGER2long(input->lenOfDatas.list.array[i], &pos));
PRINT_VDEBUG("LIBBMDPRVDEBUG Decoding loop i: %li, data string len: %li\n", i, pos);
((*mtds)[i])->AnyBuf = malloc((pos + 1) * sizeof(char));
if(((*mtds)[i])->AnyBuf == NULL) { BMD_FOK(NO_MEMORY); }
memset( ((*mtds)[i])->AnyBuf, 0, (pos + 1) * sizeof(char));
memcpy( ((*mtds)[i])->AnyBuf, str_pos, pos * sizeof(char));
/*BMD_FOK(asn_INTEGER2long(input->lenOfDatas.list.array[i], &pos));*/
((*mtds)[i])->AnySize = pos;
pos++; /*Na NULL*/
}
free(datas_str); datas_str = NULL;
}
return BMD_OK;
}
/*Zamienia liste wynikow otrzymana z serwera na plik DVCS. Mozna podac rowniez oid metadanej
ktora tylko bedzie wstawiona do wyniku.
twf_soap - struktura przechowujaca zaalokowana w soap pamiec.
twf_metadata_array_struct - tablica metadanych
twf_metadata_count - wielkosc tablicy metadanych
twf_tmp_csv_file - bufor w pamiecie przechowujacy zawartosc generowanego pliku
twf_csv_delimiter - znak jakim nalezy rozdzielac poszczegolne wartosci.
twf_first_run_flag - flaga okreslajaca czy jest to pierwsze wywolanie funkcji dla danego datagramu 1 - tak, 0 nie
twf_formMtds - tablica oid metadanych, ktorych tylko mamy uzyc do generowania pliku CSV
twf_formMtds_number - numer oid z tablicy twf_formMtds*/
long MtdsListToCSV ( struct soap *twf_soap,
MetaDataBuf_t **twf_metadata_array_struct,
long twf_metadata_count,
BMD_attr_t **twf_form,
long twf_from_count,
char **twf_tmp_csv_file,
long *twf_first_run_flag,
struct bmd230__mtdsValues *twf_formMtds,
long twf_formMtds_number,
CSV_escape_conf_t *twf_CSV_escape_conf)
{
long iteration_0 = 0;
long j = 0;
long value_type = 0;
long status = 0;
long escape_type_flag = 0;
long metadata_size = 0;
char *metadata_oid_str = NULL;
char *tmp_string = NULL;
char *csv_delimiter = NULL;
char *escaped_value = NULL;
char *form_oid_str = NULL;
char *metadata_value = NULL;
if(twf_soap == NULL) { BMD_FOK(BMD_ERR_PARAM1); }
if(twf_metadata_array_struct == NULL) { BMD_FOK(BMD_ERR_PARAM2); }
if(twf_tmp_csv_file == NULL) { BMD_FOK(BMD_ERR_PARAM4); }
if(twf_CSV_escape_conf == NULL) { BMD_FOK(BMD_ERR_PARAM8); }
if(twf_CSV_escape_conf->tws_csv_delimiter == NULL)
{
asprintf(&csv_delimiter,",");
if(csv_delimiter == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
else
{
asprintf(&csv_delimiter,"%s",twf_CSV_escape_conf->tws_csv_delimiter);
if(csv_delimiter == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
if( ( ( twf_CSV_escape_conf->tws_enable_string_escaping == 1 &&
twf_CSV_escape_conf->tws_enable_number_escaping == 1 &&
twf_CSV_escape_conf->tws_enable_date_escaping == 1) ||
(twf_CSV_escape_conf->tws_enable_string_escaping == 0 &&
twf_CSV_escape_conf->tws_enable_number_escaping == 0 &&
twf_CSV_escape_conf->tws_enable_date_escaping == 0) ) && ( twf_CSV_escape_conf->src_delimeter == NULL ||
twf_CSV_escape_conf->dst_delimeter == NULL ) )
{
escape_type_flag = 1;
}
/****************************************************************/
/* pobranie oid'a metadanej z odpowiedzi od serwera BMD */
/****************************************************************/
for (j=0; j < twf_metadata_count; j++)
{/*for (j=0; j < twf_metadata_count; j++)*/
/****************************************************************/
/* pobranie oid'a metadanej z odpowiedzi od serwera BMD */
/****************************************************************/
asprintf(&metadata_oid_str, "%s", twf_metadata_array_struct[j]->OIDTableBuf);
if (metadata_oid_str==NULL)
{
continue;
}
/****************************************************************/
/* pobranie wartosci metadanej z odpowiedzi od serwera */
/****************************************************************/
metadata_value = twf_metadata_array_struct[j]->AnyBuf;
metadata_size = twf_metadata_array_struct[j]->AnySize;
value_type = 0;
/*Ustalam typ metadanej*/
if(escape_type_flag == 0)
{
for(iteration_0 = 0; iteration_0 < twf_from_count; iteration_0++)
{
status = bmd_attr_get_oid(iteration_0, twf_form, &form_oid_str);
if(status < BMD_OK)
{
BMD_FOK(BMDSOAP_SERVER_CANNOT_OBTAIN_METADATA_TYPE);
}
if( strcmp(metadata_oid_str, form_oid_str) == 0 && \
strlen(metadata_oid_str) == strlen(form_oid_str) )
{
value_type = twf_form[iteration_0]->contentType;
PRINT_VDEBUG("Metadata oid: %s metadata type: %li\n",
metadata_oid_str, value_type);
free(form_oid_str);
form_oid_str = NULL;
break;
}
free(form_oid_str);
form_oid_str = NULL;
}
}
if(twf_formMtds != NULL)
{/*if(twf_formMtds != NULL)*/
if(twf_formMtds->__ptr[twf_formMtds_number].mtdOid == NULL)
{
PRINT_ERROR("Undefined metadata OID in table at index %li\n", twf_formMtds_number);
BMD_FOK(BMDSOAP_SERVER_UNDEFINED_METADATA_OID_FORM);
}
if (strcmp(metadata_oid_str, twf_formMtds->__ptr[twf_formMtds_number].mtdOid)==0)
{/*if (strcmp(metadata_oid_str, twf_formMtds->__ptr[twf_formMtds_number].mtdOid)==0)*/
if (*twf_tmp_csv_file!=NULL)
{
if (metadata_value != NULL)
{
if(twf_formMtds_number == 0 && *twf_first_run_flag == 1)
{
status = CharEscape( (char *)metadata_value,
metadata_size,
&escaped_value,
value_type,
twf_CSV_escape_conf);
if(status < BMD_OK)
{
BMD_FOK(status);
}
asprintf(&tmp_string, "%s%s", *twf_tmp_csv_file, \
escaped_value);
}
else
{
status = CharEscape( (char *)metadata_value,
metadata_size,
&escaped_value,
value_type,
twf_CSV_escape_conf);
if(status < BMD_OK)
{
BMD_FOK(status);
}
asprintf(&tmp_string, "%s%s%s", *twf_tmp_csv_file, \
csv_delimiter, escaped_value);
}
}
else
{
if(twf_formMtds_number == 0 && *twf_first_run_flag == 1)
{
asprintf(&tmp_string, "%s%s", *twf_tmp_csv_file, "");
}
else
{
asprintf(&tmp_string, "%s%s%s", *twf_tmp_csv_file, csv_delimiter, \
"");
}
}
free(*twf_tmp_csv_file);
*twf_tmp_csv_file = tmp_string;
tmp_string = NULL;
if(*twf_tmp_csv_file == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
else
{
if (metadata_value != NULL)
{
status = CharEscape( (char *)metadata_value,
metadata_size,
&escaped_value,
value_type,
twf_CSV_escape_conf);
if(status < BMD_OK)
{
return status;
}
asprintf(twf_tmp_csv_file, "%s", escaped_value);
}
else
{
asprintf(twf_tmp_csv_file, "%s", "");
}
if(*twf_tmp_csv_file == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
*twf_first_run_flag = 0;
break;
}/*\if (strcmp(metadata_oid_str, twf_formMtds->__ptr[twf_formMtds_number].mtdOid)==0)*/
}/*if(twf_formMtds != NULL)*/
else
{/*else(twf_formMtds != NULL)*/
if (*twf_tmp_csv_file!=NULL)
{
if (metadata_value != NULL)
{
if(j == 0 && *twf_first_run_flag == 1)
{
status = CharEscape( (char *)metadata_value,
metadata_size,
&escaped_value,
value_type,
twf_CSV_escape_conf);
if(status < BMD_OK)
{
BMD_FOK(status);
}
asprintf(&tmp_string, "%s%s", *twf_tmp_csv_file, \
escaped_value);
}
else
{
status = CharEscape( (char *)metadata_value,
metadata_size,
&escaped_value,
value_type,
twf_CSV_escape_conf);
if(status < BMD_OK)
{
BMD_FOK(status);
}
asprintf(&tmp_string, "%s%s%s", *twf_tmp_csv_file, csv_delimiter, \
escaped_value);
}
}
else
{
if(j == 0 && *twf_first_run_flag == 1)
{
asprintf(&tmp_string, "%s%s", *twf_tmp_csv_file, "");
}
else
{
asprintf(&tmp_string, "%s%s%s", *twf_tmp_csv_file, csv_delimiter, "");
}
}
*twf_first_run_flag = 0;
free(*twf_tmp_csv_file);
*twf_tmp_csv_file = tmp_string;
tmp_string = NULL;
if(*twf_tmp_csv_file == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
else
{
if (metadata_value != NULL)
{
status = CharEscape( (char *)metadata_value,
metadata_size,
&escaped_value,
value_type,
twf_CSV_escape_conf);
if(status < BMD_OK)
{
BMD_FOK(status);
}
asprintf(twf_tmp_csv_file, "%s", escaped_value);
}
else
{
asprintf(twf_tmp_csv_file, "%s", "");
}
if(*twf_tmp_csv_file == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
}/*\else(twf_formMtds != NULL)*/
free(metadata_oid_str);
metadata_oid_str=NULL;
/*free_gen_buf(&metadata_value_buf);*/
free(escaped_value);
escaped_value = NULL;
}/*\for (j=0; j < twf_metadata_count; j++)*/
free(csv_delimiter);
csv_delimiter = NULL;
return BMD_OK;
}
/*
Funkcja sluzaca do escapowania w buforze wystapienia znaku.
twf_value - escapowany bufor
twf_value_count - ilosc znakow w buforze
twf_escaped_value - bufor wynikowy. Przy wywolaniu funkcji wskaznik musi wskazywac na NULL.
twf_char_to_escape - znak escapowany
twf_escape_char - ciag escapujacy dany znak
twf_enable_escaping - czy wlaczyc escapowanie - 1 tak, 0 - nie. Przydatne gdy chcemy jedynie przegrac genbuf do stringa.
*/
long CharEscape( char *twf_value,
long twf_value_count,
char **twf_escaped_value,
long twf_value_type,
CSV_escape_conf_t *twf_CSV_escape_conf)
{
char *char_to_escape = NULL;
char *escape_char = NULL;
char *value_with_null = NULL;
char *m_value_escape = NULL;
long iteration_0 = 0;
long bytes_count = 0;
long enable_escaping = 0;
long enable_CSVEscape = 1; /*Czy korzystac z funkcji Radka na razie na sztywno tak.*/
bmd_oid_xpath_t escape_conf; /*Do funkcji escape napisanej przez Radka*/
PRINT_VDEBUG("CharEscape - escaping values\n");
if(twf_value == NULL)
{
BMD_FOK(BMD_ERR_PARAM1);
}
if(twf_value_count < 1)
{
BMD_FOK(BMD_ERR_PARAM2);
}
if(twf_escaped_value == NULL)
{
BMD_FOK(BMD_ERR_PARAM3);
}
if(*twf_escaped_value != NULL)
{
BMD_FOK(BMD_ERR_PARAM3);
}
if(twf_value_type < 0 || twf_value_type > 3)
{
/*Wykomentowane bo jest potrzeba okreslenia nowych wartosci*/
/*BMD_FOK(BMD_ERR_PARAM3);*/
}
if(twf_CSV_escape_conf == NULL)
{
BMD_FOK(BMD_ERR_PARAM5);
}
if(twf_CSV_escape_conf->tws_char_to_escape == NULL)
{
PRINT_VDEBUG("No character to escape. Assuming default.\n");
asprintf(&char_to_escape,"\"");
if(char_to_escape == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
else
{
if( strlen(twf_CSV_escape_conf->tws_char_to_escape) > 0)
{
asprintf(&char_to_escape, "%s", twf_CSV_escape_conf->tws_char_to_escape);
}
else
{
asprintf(&char_to_escape,"\"");
}
if(char_to_escape == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
PRINT_VDEBUG("Character to escape: %s.\n", char_to_escape);
if(twf_CSV_escape_conf->tws_escape_char == NULL)
{
PRINT_VDEBUG("No escape character. Assuming default.\n");
asprintf(&escape_char,"\"");
if(escape_char == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
else
{
if(strlen(twf_CSV_escape_conf->tws_escape_char) > 0)
{
asprintf(&escape_char, "%s", twf_CSV_escape_conf->tws_escape_char);
}
else
{
asprintf(&escape_char,"\"");
}
if(escape_char == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
PRINT_VDEBUG("Escape character: %s.\n", escape_char);
if(twf_CSV_escape_conf->tws_m_value_escape == NULL)
{
PRINT_VDEBUG("No surrounding value escape character. Assuming default.\n");
asprintf(&m_value_escape,"\"");
if(m_value_escape == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
else
{
if(strlen(twf_CSV_escape_conf->tws_m_value_escape) > 0)
{
asprintf(&m_value_escape, "%s", twf_CSV_escape_conf->tws_m_value_escape);
}
else
{
asprintf(&m_value_escape,"\"");
}
if(m_value_escape == NULL)
{
BMD_FOK(NO_MEMORY);
}
}
PRINT_VDEBUG("Surrounding escape character: %s.\n", m_value_escape);
if(twf_CSV_escape_conf->tws_enable_escaping != 0)
{
enable_escaping = 1;
}
else
{
enable_escaping = twf_CSV_escape_conf->tws_enable_escaping;
}
PRINT_VDEBUG("Escaping enabled: %li.\n", enable_escaping);
if(enable_CSVEscape == 0 || enable_escaping == 0)
{/*if(enable_CSVEscape == 0)*/
/*Zliczanie bajtow potrzebnych na wynik*/
if(enable_escaping == 1)
{
bytes_count = 0;
for(iteration_0 = 0; iteration_0 < twf_value_count; iteration_0++)
{
bytes_count++;
if(twf_value[iteration_0] == char_to_escape[0])
{
bytes_count = bytes_count + strlen(escape_char);
}
}
}
else
{
bytes_count = twf_value_count;
}
PRINT_VDEBUG("Input buffer length: %li Output buffor length: %li.\n", twf_value_count, bytes_count);
/*Alokacja bufora wynikowego*/
*twf_escaped_value = malloc( (bytes_count + 1)*sizeof(char) );
if(*twf_escaped_value == NULL)
{
BMD_FOK(NO_MEMORY);
}
memset(*twf_escaped_value, 0, (bytes_count + 1)*sizeof(char) );
if(twf_CSV_escape_conf->src_delimeter != NULL && twf_CSV_escape_conf->dst_delimeter != NULL && \
twf_value_type == 2)
{
if(strlen(twf_CSV_escape_conf->src_delimeter) > 0 && \
strlen(twf_CSV_escape_conf->dst_delimeter) > 0)
{
for(iteration_0 = 0; iteration_0 < twf_value_count; iteration_0++)
{
if( twf_value[iteration_0] == twf_CSV_escape_conf->src_delimeter[0] )
{
(*twf_escaped_value)[iteration_0] = twf_CSV_escape_conf->dst_delimeter[0];
}
else
{
(*twf_escaped_value)[iteration_0] = twf_value[iteration_0];
}
}
}
}
if(bytes_count == twf_value_count)
{/*if(bytes_counts == twf_value_count)*/
/*Nie dokonano zadnego escapowania*/
memcpy(*twf_escaped_value, twf_value, bytes_count * sizeof(char));
PRINT_VDEBUG("No escaping needed. Output value %s. Output value length %li.\n", *twf_escaped_value,
bytes_count);
}/*\if(bytes_counts == twf_value_count)*/
else
{/*\else(bytes_counts == twf_value_count)*/
bytes_count = 0;
for(iteration_0 = 0; iteration_0 < twf_value_count; iteration_0++)
{
if(twf_value[iteration_0] == char_to_escape[0])
{
memcpy( *twf_escaped_value + bytes_count, escape_char, strlen(escape_char));
bytes_count = bytes_count + strlen(escape_char);
(*twf_escaped_value)[bytes_count] = twf_value[iteration_0];
}
else
{
(*twf_escaped_value)[bytes_count] = twf_value[iteration_0];
}
bytes_count++;
}
PRINT_VDEBUG("Escaping needed. Output value %s. Output value length %li.\n", *twf_escaped_value, \
bytes_count);
}/*\else(bytes_counts == twf_value_count)*/
}/*\if(enable_CSVEscape == 0)*/
else
{/*else(enable_CSVEscape == 0)*/
/*Wypelnienie opcji konfiguracyjnej*/
memset(&escape_conf, 0, sizeof(bmd_oid_xpath_t));
escape_conf.text_separator_char = *char_to_escape;
escape_conf.escape_char = *escape_char;
if(twf_CSV_escape_conf->src_delimeter != NULL)
{
if(strlen(twf_CSV_escape_conf->src_delimeter) > 0)
{
PRINT_VDEBUG("Source delimeter: %c\n", twf_CSV_escape_conf->src_delimeter[0] );
escape_conf.src_dec_separator = twf_CSV_escape_conf->src_delimeter[0];
}
}
else
{
PRINT_VDEBUG("No source delimeter.\n");
}
if(twf_CSV_escape_conf->dst_delimeter != NULL)
{
if(strlen(twf_CSV_escape_conf->dst_delimeter) > 0)
{
PRINT_VDEBUG("Destination delimeter: %c\n", twf_CSV_escape_conf->dst_delimeter[0] );
escape_conf.dst_dec_separator = twf_CSV_escape_conf->dst_delimeter[0];
}
}
else
{
PRINT_VDEBUG("No destination delimeter.\n");
}
value_with_null = malloc((twf_value_count + 1)* sizeof(char));
if(value_with_null == NULL)
{
BMD_FOK(NO_MEMORY);
}
memset(value_with_null, 0, (twf_value_count + 1)* sizeof(char));
memcpy(value_with_null, twf_value, twf_value_count* sizeof(char));
PRINT_VDEBUG("Before escape value: %s\n. Value type %li.", value_with_null, twf_value_type);
if( escape_conf.src_dec_separator != 0 && escape_conf.dst_dec_separator != 0 && \
(twf_value_type == 2 || twf_value_type == 4))
{
PRINT_VDEBUG("Dot to coma conversion enabled.\n");
*twf_escaped_value = CSVEscape(&escape_conf, value_with_null, 'n');
}
else
{
PRINT_VDEBUG("Dot to coma conversion disabled.\n")
*twf_escaped_value = CSVEscape(&escape_conf, value_with_null, 't');
}
if(*twf_escaped_value == NULL)
{
BMD_FOK(BMDSOAP_SERVER_CSV_ESCAPING_ERROR);
}
free(value_with_null);
value_with_null = NULL;
}/*\else(enable_CSVEscape == 0)*/
/*Otaczanie calej wartosci metadanej odpowiednim znakiem.*/
if(m_value_escape != NULL && ( \
( (twf_value_type == 0 || twf_value_type == 1) && twf_CSV_escape_conf->tws_enable_string_escaping == 1) || \
( (twf_value_type == 2 || twf_value_type == 4) && twf_CSV_escape_conf->tws_enable_number_escaping == 1) || \
(twf_value_type == 3 && twf_CSV_escape_conf->tws_enable_date_escaping == 1) ))
{
asprintf(&value_with_null,"%s%s%s", m_value_escape, *twf_escaped_value, m_value_escape);
if(value_with_null == NULL)
{
BMD_FOK(NO_MEMORY);
}
free(*twf_escaped_value);
*twf_escaped_value = value_with_null;
value_with_null = NULL;
}
PRINT_VDEBUG("After escape value: %s\n", *twf_escaped_value);
free(char_to_escape);
char_to_escape = NULL;
free(escape_char);
escape_char = NULL;
free(m_value_escape);
m_value_escape = NULL;
return BMD_OK;
}
