/**
* Check to see if all the chars in the value of a property are valid.
*
* @param value value to check
*
* @return false if a character is not valid for a value
*/
static MIDPError checkMfValueChars(const pcsl_string * mfvalue) {
jchar current;
int i = 0;
MIDPError err = ALL_OK;
GET_PCSL_STRING_DATA_AND_LENGTH(mfvalue)
if (PCSL_STRING_PARAMETER_ERROR(mfvalue)) {
err = OUT_OF_MEMORY;
} else {
while (i < mfvalue_len) {
current = mfvalue_data[i];
/* if current is a CTL character, return an error */
if ((current <= 0x1F || current == 0x7F) && (current != HT)) {
printPcslStringWithMessage("checkMfValueChars: BAD_MF_VALUE ",
mfvalue);
err = BAD_MF_VALUE;
break;
}
i++;
} /* end of while */
}
RELEASE_PCSL_STRING_DATA_AND_LENGTH
return err;
} /* end of checkMfValueChars */
/**
* Check to see if all the chars in the key of a property are valid.
*
* @param jadkey key to check
* @return BAD_JAD_KEY if a character is not valid for a key
*/
static MIDPError checkJadKeyChars(const pcsl_string * jadkey) {
jchar current;
int i = 0;
MIDPError err = ALL_OK;
GET_PCSL_STRING_DATA_AND_LENGTH(jadkey)
if (PCSL_STRING_PARAMETER_ERROR(jadkey)) {
err = OUT_OF_MEMORY;
} else {
while (i < jadkey_len) {
current = jadkey_data[i];
if (current <= 0x1F
|| current == 0x7F
|| current == '('
|| current == ')'
|| current == '<'
|| current == '>'
|| current == '@'
|| current == ','
|| current == ';'
|| current == '\''
|| current == '"'
|| current == '/'
|| current == '['
|| current == ']'
|| current == '?'
|| current == '='
|| current == '{'
|| current == '}'
|| current == SP
|| current == HT) {
printPcslStringWithMessage("checkJadKeyChars: BAD_JAD_KEY ",
jadkey);
err = BAD_JAD_KEY;
break;
}
i++;
} /* end of while */
}
RELEASE_PCSL_STRING_DATA_AND_LENGTH
return err;
}
/**
* Check to see if all the chars in the key of a property are valid.
*
* @param key key to check
*
* @return an error if a character is not valid for a key
*/
static MIDPError checkMfKeyChars(const pcsl_string * mfkey) {
/* IMPL NOTE: why chars in manifest key are different from jad key? */
jchar current;
int i = 0;
MIDPError err = ALL_OK;
GET_PCSL_STRING_DATA_AND_LENGTH(mfkey)
if (PCSL_STRING_PARAMETER_ERROR(mfkey)) {
err = OUT_OF_MEMORY;
} else {
while (i < mfkey_len) {
current = mfkey_data[i];
i++;
if (current >= 'A' && current <= 'Z') {
continue;
}
if (current >= 'a' && current <= 'z') {
continue;
}
if (current >= '0' && current <= '9') {
continue;
}
if ((i - 1) > 0 && (current == '-' || current == '_')) {
continue;
}
printPcslStringWithMessage("checkMfKeyChars: BAD_MF_KEY ", mfkey);
err = BAD_MF_KEY;
break;
} /* end of while */
}
RELEASE_PCSL_STRING_DATA_AND_LENGTH
return err;
} /* end of checkMfKeyChars */
static MidpProperties midpParseMf(jchar* jchar_buffer) {
MidpProperties mfsmp = {0, ALL_OK, NULL};
pcsl_string mfkey;
pcsl_string mfkey_trimmed;
pcsl_string mfvalue;
pcsl_string mfvalue_trimmed;
pcsl_string mfline;
MIDPError err;
pcsl_string_status rc;
int countLines = 0;
int index = 0;
int count = 0;
if (!jchar_buffer) {
mfsmp.status = BAD_PARAMS;
return mfsmp;
}
countLines = count_mf_lines(jchar_buffer);
if (countLines <= 0) {
REPORT_INFO(LC_AMS, "midpParseMf(): Empty manifest.");
mfsmp.status = OUT_OF_MEMORY;
return mfsmp;
}
mfsmp.pStringArr = alloc_pcsl_string_list(countLines * 2);
if (mfsmp.pStringArr == NULL) {
mfsmp.status = OUT_OF_MEMORY;
return mfsmp;
}
mfsmp.numberOfProperties = countLines;
for (count = 0; count < countLines * 2 ;
/* count increased at the end of for */ ) {
/* memory for the line is allocated here */
/* line continuation striped out */
err = readMfLine(&jchar_buffer, &mfline);
if (OUT_OF_MEMORY == err) {
midp_free_properties(&mfsmp);
mfsmp.status = OUT_OF_MEMORY;
return mfsmp;
} else if (END_OF_MF == err) {
/* we are done */
mfsmp.status = ALL_OK;
break;
}
index = pcsl_string_index_of(&mfline, ':');
if (index <= 0) {
mfsmp.status = BAD_MF_KEY;
pcsl_string_free(&mfline);
continue;
}
/* memory for mfkey is allocated here */
if (PCSL_STRING_OK !=
pcsl_string_substring(&mfline, 0, index, &mfkey)) {
midp_free_properties(&mfsmp);
mfsmp.status = OUT_OF_MEMORY;
pcsl_string_free(&mfline);
return mfsmp;
}
rc = pcsl_string_trim(&mfkey, &mfkey_trimmed);
pcsl_string_free(&mfkey);
if (PCSL_STRING_OK != rc) {
mfsmp.status = OUT_OF_MEMORY;
midp_free_properties(&mfsmp);
pcsl_string_free(&mfline);
return mfsmp;
}
if (pcsl_string_length(&mfkey_trimmed) < 1) {
mfsmp.status = BAD_PARAMS;
pcsl_string_free(&mfline);
pcsl_string_free(&mfkey_trimmed);
continue;
}
err = checkMfKeyChars(&mfkey_trimmed);
if (OUT_OF_MEMORY == err) {
mfsmp.status = OUT_OF_MEMORY;
midp_free_properties(&mfsmp);
pcsl_string_free(&mfline);
pcsl_string_free(&mfkey_trimmed);
return mfsmp;
} else if (BAD_MF_KEY == err) {
mfsmp.status = BAD_MF_KEY;
pcsl_string_free(&mfline);
pcsl_string_free(&mfkey_trimmed);
continue;
}
rc = pcsl_string_substring(&mfline, index + 1,
pcsl_string_length(&mfline), &mfvalue);
/* free the mfline once we have got the key and value */
pcsl_string_free(&mfline);
if (PCSL_STRING_OK != rc) {
mfsmp.status = OUT_OF_MEMORY;
midp_free_properties(&mfsmp);
pcsl_string_free(&mfkey_trimmed);
return mfsmp;
}
/* memory for value is allocated here */
rc = pcsl_string_trim(&mfvalue, &mfvalue_trimmed);
pcsl_string_free(&mfvalue);
if (PCSL_STRING_OK != rc) {
mfsmp.status = OUT_OF_MEMORY;
midp_free_properties(&mfsmp);
pcsl_string_free(&mfkey_trimmed);
return mfsmp;
}
if (pcsl_string_is_null(&mfvalue_trimmed)) {
mfsmp.status = NULL_LEN;
pcsl_string_free(&mfkey_trimmed);
continue;
}
err = checkMfValueChars(&mfvalue_trimmed);
if (OUT_OF_MEMORY == err) {
mfsmp.status = OUT_OF_MEMORY;
midp_free_properties(&mfsmp);
pcsl_string_free(&mfkey_trimmed);
pcsl_string_free(&mfvalue_trimmed);
return mfsmp;
} else if (BAD_MF_VALUE == err) {
mfsmp.status = BAD_MF_VALUE;
pcsl_string_free(&mfkey_trimmed);
pcsl_string_free(&mfvalue_trimmed);
continue;
}
printPcslStringWithMessage("midpParseMf()", &mfkey_trimmed);
printPcslStringWithMessage(" = ", &mfvalue_trimmed);
/* Store key:value pair. */
mfsmp.pStringArr[count] = mfkey_trimmed;
mfsmp.pStringArr[count+1] = mfvalue_trimmed;
count += 2;
} /* end of for */
mfsmp = verifyMfMustProperties(mfsmp);
REPORT_INFO3(LC_AMS,
"End of midpParseMf: Status=%d, count=%d, countLines=%d",
mfsmp.status, count, countLines);
return mfsmp;
} /* end of midpParseMf */
MidpProperties mf_main(char* mfbuf, int mflength) {
MidpProperties mfsmp = {0, ALL_OK, NULL};
jchar* save_jchar_buffer = NULL;
jchar* jchar_buffer = NULL;
int jbufsize = -1;
#if REPORT_LEVEL <= LOG_INFORMATION
int res = 0;
#endif
if ((mflength <= 0) || (!mfbuf)) {
mfsmp.status = OUT_OF_MEMORY;
return mfsmp;
}
jbufsize = mflength * sizeof(jchar);
jchar_buffer = (jchar*)midpMalloc(jbufsize+2);
if (!jchar_buffer) {
midpFree(mfbuf);
mfsmp.status = OUT_OF_MEMORY;
return mfsmp;
}
memset(jchar_buffer,0,(jbufsize + 2));
convertChar2JChar(mfbuf,jchar_buffer,mflength);
midpFree(mfbuf);
save_jchar_buffer = jchar_buffer;
REPORT_INFO(LC_AMS,
"######################### Start of manifest parsing");
/* during execution of this, jchar_buffer pointer will be changed */
mfsmp = midpParseMf(jchar_buffer);
midpFree(save_jchar_buffer);
switch (mfsmp.status) {
case NO_SUITE_NAME_PROP:
midp_free_properties(&mfsmp);
return mfsmp;
case NO_SUITE_VENDOR_PROP:
midp_free_properties(&mfsmp);
return mfsmp;
case NO_SUITE_VERSION_PROP:
midp_free_properties(&mfsmp);
return mfsmp;
case NO_MIDLET_ONE_PROP:
midp_free_properties(&mfsmp);
return mfsmp;
case NO_MICROEDITION_PROFILE_PROP:
midp_free_properties(&mfsmp);
return mfsmp;
case NO_MICROEDITION_CONFIGURATION_PROP:
REPORT_INFO1(LC_AMS,
"Manifest MUST property missing %d", mfsmp.status);
return mfsmp;
case BAD_PARAMS:
case BAD_MF_KEY:
case BAD_MF_VALUE:
REPORT_INFO1(LC_AMS,
"Some NOT MUST Manifest property is not valid %d",
mfsmp.status);
break;
case ALL_OK:
REPORT_INFO1(LC_AMS, "Manifest ALL_OK %d", mfsmp.status);
break;
default:
REPORT_INFO1(LC_AMS, "MF parse OUT_OF_MEMORY %d", mfsmp.status);
/* for unknown result assuming OUT_OF_MEMORY */
return mfsmp;
} /* end of switch */
#if REPORT_LEVEL <= LOG_INFORMATION
reportToLog(LOG_INFORMATION, LC_AMS, "%s %s %d",
"########################### End of manifest parsing: ",
"mf_main() : number of Manifest properties = ",
mfsmp.numberOfProperties);
for (res = 0; res < mfsmp.numberOfProperties * 2; res += 2) {
printPcslStringWithMessage(" ", &mfsmp.pStringArr[res]);
printPcslStringWithMessage(" ", &mfsmp.pStringArr[res+1]);
}
#endif
return mfsmp;
} /* end of mf_main */
static MidpProperties midpParseJad(jchar* jchar_buffer) {
MidpProperties jadsmp = {0, ALL_OK, NULL};
pcsl_string jadkey;
pcsl_string jadkey_trimmed;
pcsl_string jadvalue;
pcsl_string jadvalue_trimmed;
pcsl_string jadline;
MIDPError err;
pcsl_string_status rc;
int countLines = 0;
jint index = 0;
int count = 0;
if (!jchar_buffer) {
jadsmp.status = BAD_PARAMS;
return jadsmp;
}
countLines = count_jad_lines(jchar_buffer);
if (countLines <= 0) {
REPORT_INFO(LC_AMS, "midpParseJad(): Empty jad file.");
jadsmp.status = OUT_OF_MEMORY;
return jadsmp;
}
jadsmp.pStringArr = alloc_pcsl_string_list(countLines * 2);
if (jadsmp.pStringArr == NULL) {
jadsmp.status = OUT_OF_MEMORY;
return jadsmp;
}
jadsmp.numberOfProperties = countLines;
for (count = 0; count < countLines * 2 ;
/* count increased at the end of for */ ) {
/* memory for the line is allocated here */
err = readJadLine(&jchar_buffer, &jadline);
if (OUT_OF_MEMORY == err) {
midp_free_properties(&jadsmp);
jadsmp.status = OUT_OF_MEMORY;
return jadsmp;
} else if (END_OF_JAD == err) {
/* we are done */
jadsmp.status = ALL_OK;
break;
}
index = pcsl_string_index_of(&jadline, ':');
if (index <= 0) {
jadsmp.status = BAD_JAD_KEY;
pcsl_string_free(&jadline);
continue;
}
/* memory for key is allocated here */
if (PCSL_STRING_OK !=
pcsl_string_substring(&jadline, 0, index, &jadkey)) {
midp_free_properties(&jadsmp);
jadsmp.status = OUT_OF_MEMORY;
pcsl_string_free(&jadline);
return jadsmp;
}
rc = pcsl_string_trim(&jadkey, &jadkey_trimmed);
pcsl_string_free(&jadkey);
if (PCSL_STRING_OK != rc) {
jadsmp.status = OUT_OF_MEMORY;
midp_free_properties(&jadsmp);
pcsl_string_free(&jadline);
return jadsmp;
}
if (pcsl_string_length(&jadkey_trimmed) < 1) {
jadsmp.status = BAD_PARAMS;
pcsl_string_free(&jadline);
pcsl_string_free(&jadkey_trimmed);
continue;
}
err = checkJadKeyChars(&jadkey_trimmed);
if (OUT_OF_MEMORY == err) {
jadsmp.status = OUT_OF_MEMORY;
midp_free_properties(&jadsmp);
pcsl_string_free(&jadline);
pcsl_string_free(&jadkey_trimmed);
return jadsmp;
} else if (BAD_JAD_KEY == err) {
jadsmp.status = BAD_JAD_KEY;
pcsl_string_free(&jadline);
pcsl_string_free(&jadkey_trimmed);
continue;
}
rc = pcsl_string_substring(&jadline, index + 1,
pcsl_string_length(&jadline), &jadvalue);
/* free the jadline once we have got the key and value */
pcsl_string_free(&jadline);
if (PCSL_STRING_OK != rc) {
jadsmp.status = OUT_OF_MEMORY;
midp_free_properties(&jadsmp);
pcsl_string_free(&jadkey_trimmed);
return jadsmp;
}
/* memory for value is allocated here */
rc = pcsl_string_trim(&jadvalue, &jadvalue_trimmed);
pcsl_string_free(&jadvalue);
if (PCSL_STRING_OK != rc) {
jadsmp.status = OUT_OF_MEMORY;
midp_free_properties(&jadsmp);
pcsl_string_free(&jadkey_trimmed);
return jadsmp;
}
if (pcsl_string_is_null(&jadvalue_trimmed)) {
jadsmp.status = NULL_LEN;
pcsl_string_free(&jadkey_trimmed);
continue;
}
err = checkJadValueChars(&jadvalue_trimmed);
if (OUT_OF_MEMORY == err) {
jadsmp.status = OUT_OF_MEMORY;
midp_free_properties(&jadsmp);
pcsl_string_free(&jadkey_trimmed);
pcsl_string_free(&jadvalue_trimmed);
return jadsmp;
} else if (BAD_JAD_VALUE == err) {
jadsmp.status = BAD_JAD_VALUE;
pcsl_string_free(&jadkey_trimmed);
pcsl_string_free(&jadvalue_trimmed);
continue;
}
printPcslStringWithMessage("midpParseJad()", &jadkey_trimmed);
printPcslStringWithMessage("midpParseJad()", &jadvalue_trimmed);
/* Store key:value pair. */
jadsmp.pStringArr[count] = jadkey_trimmed;
jadsmp.pStringArr[count+1] = jadvalue_trimmed;
count += 2;
} /* end of for */
jadsmp = verifyJadMustProperties(jadsmp);
REPORT_INFO3(LC_AMS,
"End jad parsing. Status=%d, count=%d, countLines=%d.",
jadsmp.status, count, countLines);
return jadsmp;
} /* end of midpParseJad */
MidpProperties jad_main(char* jadbuf, int jadsize) {
MidpProperties jadsmp = {0,ALL_OK,NULL};
jchar* jchar_buffer = NULL;
jchar* save_jchar_buffer = NULL;
int jbufsize = -1;
#if REPORT_LEVEL <= LOG_INFORMATION
int res = 0;
#endif
jbufsize = jadsize * sizeof(jchar);
jchar_buffer = (jchar*)midpMalloc(jbufsize+2);
if (!jchar_buffer) {
midpFree(jadbuf);
jadsmp.status = OUT_OF_MEMORY;
return jadsmp;
}
memset(jchar_buffer,0,(jbufsize + 2));
convertChar2JChar(jadbuf,jchar_buffer,jadsize);
midpFree(jadbuf);
save_jchar_buffer = jchar_buffer;
REPORT_INFO(LC_AMS, "####################### Start JAD parsing");
/* during execution of this function jadbuf pointer will be changed
status will be set during midpParseJad() execution */
jadsmp = midpParseJad(jchar_buffer);
midpFree(save_jchar_buffer);
switch (jadsmp.status) {
case OUT_OF_STORAGE:
REPORT_WARN1(LC_AMS, "OUT_OF_STORAGE by JAD %d", jadsmp.status);
midp_free_properties(&jadsmp);
return jadsmp;
case NO_JAR_URL_PROP:
REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status);
midp_free_properties(&jadsmp);
return jadsmp;
case NO_SUITE_NAME_PROP:
REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status);
midp_free_properties(&jadsmp);
return jadsmp;
case NO_SUITE_VENDOR_PROP:
REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status);
midp_free_properties(&jadsmp);
return jadsmp;
case NO_SUITE_VERSION_PROP:
REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status);
midp_free_properties(&jadsmp);
return jadsmp;
case NO_JAR_SIZE_PROP:
REPORT_WARN1(LC_AMS, "Jad property missing %d", jadsmp.status);
midp_free_properties(&jadsmp);
return jadsmp;
case NUMBER_ERROR:
REPORT_INFO1(LC_AMS,
"Error during parsing JAR size written in JAD %d",
jadsmp.status);
midp_free_properties(&jadsmp);
return jadsmp;
case BAD_PARAMS:
case BAD_JAD_KEY:
case BAD_JAD_VALUE:
REPORT_INFO1(LC_AMS,
"Some NOT mandatory Jad properties is not valid %d",
jadsmp.status);
break;
case ALL_OK:
REPORT_INFO1(LC_AMS, "Jad ALL_OK %d", jadsmp.status);
break;
default:
/* for an unknown result assuming OUT_OF_MEMORY */
REPORT_INFO1(LC_AMS, "JAD parse OUT_OF_MEMORY %d", jadsmp.status);
return jadsmp;
} /* end of switch */
#if REPORT_LEVEL <= LOG_INFORMATION
reportToLog(LOG_INFORMATION, LC_AMS,
"######################### End of JAD parsing\n"
"jad_main() : number of JAD properties = %d",
jadsmp.numberOfProperties);
for (res = 0; res < jadsmp.numberOfProperties*2; res+=2 ) {
printPcslStringWithMessage(" ", &jadsmp.pStringArr[res]);
printPcslStringWithMessage(" ", &jadsmp.pStringArr[res+1]);
}
#endif
return jadsmp;
} /* end of jad_main */
/**
* Version string may looks like Major:Minor:Micro
*
* @param ver pcsl_string that contains a version
* @param major Major version
* @param minor Minor version
* @param micro Micro version
* @return 1 == OK
* 0 = BAD version
*/
int midpGetVersion(const pcsl_string * ver, int *major, int *minor, int *micro) {
int ma = 0;
int mi = 0;
int mc = 0;
int count = 0;
int dot_count = 0;
int segment_size = 0;
const jchar* p = NULL;
const jchar* ver_data;
jsize ver_len = pcsl_string_utf16_length(ver);
*major = -1;
*minor = -1;
*micro = -1;
if ((ver_len <= 0) || (ver_len > 8)) {
return 0;
}
printPcslStringWithMessage("ver", ver);
ver_data = pcsl_string_get_utf16_data(ver);
if (NULL == ver_data) {
return 0;
}
/* most checking done here */
for (count=0; count < ver_len; count++) {
if ((ver_data[count] >= '0') && (ver_data[count] <= '9')) {
segment_size++;
} else if (ver_data[count] == '.') {
if ((segment_size == 0) || (segment_size > 2)) {
REPORT_ERROR1(LC_AMS, "segment size wrong %d",
segment_size);
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
dot_count++;
segment_size = 0;
} else {
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
} /* end of for */
/* can't be more then 2 dots in version */
if (dot_count > 2) {
REPORT_ERROR1(LC_AMS, "too many dots (%d)", dot_count);
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
/*
* Get major version
*/
for (p = ver_data, count = 0; (*p != '.') && (count < ver_len); ) {
if (*p >= '0' && *p <= '9') {
ma *= 10;
ma += *p - '0';
} else {
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
count++;
p++;
} /* end of for */
if(*p == '.') {
p++;
count++;
}
/*
* Get minor version.
*/
for ( ; (*p != '.') && (count < ver_len); ) {
if (*p >= '0' && *p <= '9') {
mi *= 10;
mi += *p - '0';
} else {
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
count++;
p++;
}
if(*p == '.') {
p++;
count++;
}
/*
* Get micro version; if it exists..
*/
for ( ; (*p != '.') && (count < ver_len); ) {
if (*p >= '0' && *p <= '9') {
mc *= 10;
mc += *p - '0';
} else {
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
p++;
count++;
}
*major = ma;
*minor = mi;
*micro = mc;
pcsl_string_release_utf16_data(ver_data, ver);
return 1;
}
