void read_blif(char* blif_file, int lut_size)
{
char buffer[BUFSIZE];
int pass, done, doall;
blif = my_fopen(blif_file, "r", 0);
for (doall = 0; doall <= 1; doall++) {
init_parse(doall);
/* Three passes to ensure inputs are first blocks, outputs second and *
* LUTs and latches third. Just makes the output netlist more readable. */
for (pass = 1; pass <= 3; pass++) {
linenum = 0; /* Reset line number. */
done = 0;
while ((my_fgets(buffer, BUFSIZE, blif) != NULL) && !done) {
get_tok(buffer, pass, doall, &done, lut_size);
}
rewind(blif); /* Start at beginning of file again */
}
}
fclose(blif);
check_net(lut_size);
free_parse();
}
V7_PRIVATE enum v7_tok next_tok(struct v7 *v7) {
v7->pstate.line_no += skip_to_next_tok(&v7->pstate.pc);
v7->tok = v7->pstate.pc;
v7->cur_tok = get_tok(&v7->pstate.pc, &v7->cur_tok_dbl);
v7->tok_len = v7->pstate.pc - v7->tok;
v7->pstate.line_no += skip_to_next_tok(&v7->pstate.pc);
printf("--> %d [%.*s]\n", v7->cur_tok, (int) v7->tok_len, v7->tok);
return v7->cur_tok;
}
/*
* checks if token "rc" is present into the JSON string and if its value is 0
* returns 0 if error, 1 if success
*/
static int rc_ok (char *js, jsmntok_t *tok, int ntok) {
debug (4, "==> rc_ok");
int r = get_tok (js, tok, ntok, "rc");
if (r == -1) {
debug (1, "token rc not found in JSON response");
return 0;
}
if (TOK_CMP (js, tok[r], "0") == 0) {
debug (1, "token rc has wrong value, expected 0");
return 0;
}
return 1;
}
/*
* returns 1 if SUCCESS, -1 if error
* sp_username: specifies the username in SecurePass format, i.e. user@realm
* secret: concatenation of OTP and password
*/
int sp_user_auth (const char *sp_username, const char* secret) {
int len;
jsmntok_t *tok;
struct MemoryStruct chunk;
/* debug (4, "==> sp_user_auth, sp_username=%s secret=%s", sp_username, secret); */
debug (4, "==> sp_user_auth, sp_username=%s", sp_username);
if ((sp_config.status != SP_INITED)) {
if (!(sp_init ())) return -1;
}
if (sp_username == NULL) {
error ("sp_user_auth() called with username=NULL");
return -1;
}
if (secret == NULL) {
error ("sp_user_auth() called with secret=NULL");
return -1;
}
/* call curl */
char post_data[(strlen ("USERNAME="******"SECRET") + strlen (secret) + 2)];
sprintf (post_data, "USERNAME=%s&SECRET=%s", sp_username, secret);
len = do_curl(sp_config.URL_u_auth, post_data, &tok, (struct MemoryStruct *) &chunk);
if (len == -1) {
return -1;
}
/* check for value of rc token */
if (!(rc_ok (chunk.memory, tok, len))) {
free (tok);
free (chunk.memory);
return -1;
}
int r = get_tok (chunk.memory, tok, len, "authenticated");
if (r == -1) {
debug (1, "token 'authenticated' not found in JSON response");
} else {
if (TOK_CMP (chunk.memory, tok[r], "true") == 0) {
debug (1, "token 'authenticated' has wrong value, expected true");
/* set error */
r = -1;
}
}
if (r == -1) {
free (tok);
free (chunk.memory);
return -1;
}
return 1;
}
void sysv_task() {
std::string path = "/tmp/mem.temp";
key_t key = get_tok(path, 1);
size_t size = 1024;
int shmid = shmget(key, size, 0666 | IPC_CREAT);
if (shmid == -1) perror("shmget");
char *data = (char *)shmat(shmid, (void *)NULL, SHM_RND);
if (data == (char*)(-1)) perror("shmat");
for (int i = 0; i < 1024; i++) data[i] = 42;
shmdt(data);
}
int main(void) {
const char *src = "for (var fo++ = 1; /= <= 1.17; x<<) { == <<=, 'x')} ";
enum v7_tok tok;
double num;
const char *p = src;
skip_to_next_tok(&src);
while ((tok = get_tok(&src, &num)) != TOK_END_OF_INPUT) {
printf("%d [%.*s]\n", tok, (int) (src - p), p);
skip_to_next_tok(&src);
p = src;
}
printf("%d [%.*s]\n", tok, (int) (src - p), p);
return 0;
}
static jboolean
get_boolean(char **pstr, jboolean *answer)
{
char buf[80];
*answer = JNI_FALSE;
/*LINTED*/
if (get_tok(pstr, buf, (int)sizeof(buf), ',')) {
if (strcmp(buf, "y") == 0) {
*answer = JNI_TRUE;
return JNI_TRUE;
} else if (strcmp(buf, "n") == 0) {
*answer = JNI_FALSE;
return JNI_TRUE;
}
}
return JNI_FALSE;
}
void main()
{
printf("input first num : ");
int a;
if (get_num(stdin, &a) == TOK_INVALID)
{
printf("invalid num\n");
return;
}
printf("input operator : ");
TOK_TYPE op;
op = get_tok(stdin);
if (op == TOK_INVALID)
{
printf("invalid operator\n");
return;
}
getchar();
printf("input second num : ");
int b;
if (get_num(stdin, &b) == TOK_INVALID)
{
printf("invalid num\n");
return;
}
if (op == TOK_PLUS)
{
printf("first + second = %d\n", a + b);
}
else if (op == TOK_MINUS)
{
printf("first - second = %d\n", a - b);
}
else if (op == TOK_MUL)
{
printf("first * second = %d\n", a * b);
}
}
void
read_blif(char *blif_file,
boolean sweep_hanging_nets_and_inputs,
t_model *user_models,
t_model *library_models)
{
char buffer[BUFSIZE];
int pass, doall;
boolean done;
boolean add_truth_table;
t_model *inpad_model, *outpad_model, *logic_model, *latch_model;
blif = fopen(blif_file, "r");
if(blif == NULL) {
printf("Failed to open blif file %s\n", blif_file);
exit(1);
}
load_default_models(library_models, &inpad_model, &outpad_model, &logic_model, &latch_model);
/* doall = 0 means do a counting pass, doall = 1 means allocate and load data structures */
for(doall = 0; doall <= 1; doall++)
{
init_parse(doall);
/* Three passes to ensure inputs are first blocks, outputs second and *
* LUTs and latches third, subckts last. Just makes the output netlist more readable. */
for(pass = 0; pass <= 4; pass++)
{
linenum = 0; /* Reset line number. */
done = FALSE;
add_truth_table = FALSE;
model_lines = 0;
while(my_fgets(buffer, BUFSIZE, blif) != NULL)
{
get_tok(buffer, pass, doall, &done, &add_truth_table, inpad_model, outpad_model, logic_model, latch_model, user_models);
}
rewind(blif); /* Start at beginning of file again */
}
}
fclose(blif);
check_net(sweep_hanging_nets_and_inputs);
free_parse();
}
void read_net (char *net_file, t_subblock_data *subblock_data_ptr) {
/* Main routine that parses a netlist file in my (.net) format. */
char buf[BUFSIZE], *ptr;
int doall;
FILE *fp_net;
/* Make two variables below accessible anywhere in the module because I'm *
* too lazy to pass them all over the place. */
max_subblocks_per_block = subblock_data_ptr->max_subblocks_per_block;
subblock_lut_size = subblock_data_ptr->subblock_lut_size;
fp_net = my_fopen (net_file, "r", 0);
/* First pass builds the symbol table and counts the number of pins *
* on each net. Then I allocate exactly the right amount of storage *
* for each net. Finally, the second pass loads the block and net *
* arrays. */
for (doall=0;doall<=1;doall++) { /* Pass number. */
init_parse(doall);
linenum = 0; /* Reset line number. */
ptr = my_fgets (buf, BUFSIZE, fp_net);
while (ptr != NULL) {
ptr = get_tok (buf, doall, fp_net);
}
rewind (fp_net); /* Start at beginning of file again */
}
fclose(fp_net);
/* Return the three data structures below through subblock_data_ptr. */
subblock_data_ptr->subblock_inf = subblock_inf;
subblock_data_ptr->num_subblocks_per_block = num_subblocks_per_block;
subblock_data_ptr->chunk_head_ptr = ch_subblock_head_ptr;
check_netlist (subblock_data_ptr, num_driver);
free_parse();
}
/*
* copy_tok() copies the second token of a JSON pair into user buffer, if the first token matches a given string
* js: pointer to the JSON buffer
* tok: JSMN pointers to JSON tokens
* ntok: number of JMNS pointers
* cp_tok->buf: output user buffer - must be allocated by caller
* cp_tok->buflen: buffer length
* cp_tok->offset: buffer offset where to copy the token found
* cp_tok->status: set to -1 if not enough space to contain the token found
* first: value to be matched for first token
* s_def: string to be returned if not matched
*/
static void copy_tok (char *js, jsmntok_t *tok, int ntok, cp_tok_t *cp_tok, char *first,
char *s_def) {
debug (4, "==> copy_tok");
int r = get_tok (js, tok, ntok, first);
if (r == -1) {
/* token not found in JSON buffer: copy the default string into user buffer */
debug (4, "token %s not found in JSON response", first);
int l = strlen (s_def);
if ((cp_tok->buflen - cp_tok->offset) < (l + 1)) {
/* buffer is too small. Set error into cp_tok descriptor and update offset */
cp_tok->status = -1;
cp_tok->offset += (l + 1);
return;
}
if (cp_tok->status != -1) {
/* if cp_tok descriptor has error set, don't copy back data and only update offset */
strcpy (cp_tok->buf + cp_tok->offset, s_def);
}
cp_tok->offset += (l + 1);
}
else {
/* token found in JSON buffer */
int l = tok[r].end - tok[r].start;
if ((cp_tok->buflen - cp_tok->offset) < (l + 1)) {
/* buffer is too small. Set error into cp_tok descriptor and update offset */
cp_tok->status = -1;
cp_tok->offset += (l + 1);
return;
}
if (cp_tok->status != -1) {
/* if cp_tok descriptor has error set, don't copy back data and only update offset */
memcpy (cp_tok->buf + cp_tok->offset, (js + tok[r].start), l);
*(cp_tok->buf + cp_tok->offset + l) = 0;
}
cp_tok->offset += (l + 1);
return;
}
}
bool
_bson_iso8601_date_parse (const char *str,
int32_t len,
int64_t *out,
bson_error_t *error)
{
const char *ptr;
int32_t remaining = len;
const char *year_ptr;
const char *month_ptr;
const char *day_ptr;
const char *hour_ptr;
const char *min_ptr;
const char *sec_ptr;
const char *millis_ptr;
const char *tz_ptr;
int32_t year_len = 0;
int32_t month_len = 0;
int32_t day_len = 0;
int32_t hour_len = 0;
int32_t min_len = 0;
int32_t sec_len = 0;
int32_t millis_len = 0;
int32_t tz_len = 0;
int32_t year;
int32_t month;
int32_t day;
int32_t hour;
int32_t min;
int32_t sec = 0;
int64_t millis = 0;
int32_t tz_adjustment = 0;
struct bson_tm posix_date = {0};
#define DATE_PARSE_ERR(msg) \
bson_set_error (error, \
BSON_ERROR_JSON, \
BSON_JSON_ERROR_READ_INVALID_PARAM, \
"Could not parse \"%s\" as date: " msg, \
str); \
return false
#define DEFAULT_DATE_PARSE_ERR \
DATE_PARSE_ERR ("use ISO8601 format yyyy-mm-ddThh:mm plus timezone, either" \
" \"Z\" or like \"+0500\"")
ptr = str;
/* we have to match at least yyyy-mm-ddThh:mm */
if (!(get_tok ("-", &ptr, &remaining, &year_ptr, &year_len) &&
get_tok ("-", &ptr, &remaining, &month_ptr, &month_len) &&
get_tok ("T", &ptr, &remaining, &day_ptr, &day_len) &&
get_tok (":", &ptr, &remaining, &hour_ptr, &hour_len) &&
get_tok (":+-Z", &ptr, &remaining, &min_ptr, &min_len))) {
DEFAULT_DATE_PARSE_ERR;
}
/* if the minute has a ':' at the end look for seconds */
if (min_ptr[min_len] == ':') {
if (remaining < 2) {
DATE_PARSE_ERR ("reached end of date while looking for seconds");
}
get_tok (".+-Z", &ptr, &remaining, &sec_ptr, &sec_len);
if (!sec_len) {
DATE_PARSE_ERR ("minute ends in \":\" seconds is required");
}
}
/* if we had a second and it is followed by a '.' look for milliseconds */
if (sec_len && sec_ptr[sec_len] == '.') {
if (remaining < 2) {
DATE_PARSE_ERR ("reached end of date while looking for milliseconds");
}
get_tok ("+-Z", &ptr, &remaining, &millis_ptr, &millis_len);
if (!millis_len) {
DATE_PARSE_ERR ("seconds ends in \".\", milliseconds is required");
}
}
/* backtrack by 1 to put ptr on the timezone */
ptr--;
remaining++;
get_tok ("", &ptr, &remaining, &tz_ptr, &tz_len);
if (!parse_num (year_ptr, year_len, 4, -9999, 9999, &year)) {
DATE_PARSE_ERR ("year must be an integer");
}
/* values are as in struct tm */
year -= 1900;
if (!parse_num (month_ptr, month_len, 2, 1, 12, &month)) {
DATE_PARSE_ERR ("month must be an integer");
}
/* values are as in struct tm */
month -= 1;
if (!parse_num (day_ptr, day_len, 2, 1, 31, &day)) {
DATE_PARSE_ERR ("day must be an integer");
}
if (!parse_num (hour_ptr, hour_len, 2, 0, 23, &hour)) {
DATE_PARSE_ERR ("hour must be an integer");
}
if (!parse_num (min_ptr, min_len, 2, 0, 59, &min)) {
DATE_PARSE_ERR ("minute must be an integer");
}
if (sec_len && !parse_num (sec_ptr, sec_len, 2, 0, 60, &sec)) {
DATE_PARSE_ERR ("seconds must be an integer");
}
if (tz_len > 0) {
if (tz_ptr[0] == 'Z' && tz_len == 1) {
/* valid */
} else if (tz_ptr[0] == '+' || tz_ptr[0] == '-') {
int32_t tz_hour;
int32_t tz_min;
if (tz_len != 5 || !digits_only (tz_ptr + 1, 4)) {
DATE_PARSE_ERR ("could not parse timezone");
}
if (!parse_num (tz_ptr + 1, 2, -1, -23, 23, &tz_hour)) {
DATE_PARSE_ERR ("timezone hour must be at most 23");
}
if (!parse_num (tz_ptr + 3, 2, -1, 0, 59, &tz_min)) {
DATE_PARSE_ERR ("timezone minute must be at most 59");
}
/* we inflect the meaning of a 'positive' timezone. Those are hours
* we have to substract, and vice versa */
tz_adjustment =
(tz_ptr[0] == '-' ? 1 : -1) * ((tz_min * 60) + (tz_hour * 60 * 60));
if (!(tz_adjustment > -86400 && tz_adjustment < 86400)) {
DATE_PARSE_ERR ("timezone offset must be less than 24 hours");
}
} else {
DATE_PARSE_ERR ("timezone is required");
}
}
if (millis_len > 0) {
int i;
int magnitude;
millis = 0;
if (millis_len > 3 || !digits_only (millis_ptr, millis_len)) {
DATE_PARSE_ERR ("milliseconds must be an integer");
}
for (i = 1, magnitude = 1; i <= millis_len; i++, magnitude *= 10) {
millis += (millis_ptr[millis_len - i] - '0') * magnitude;
}
if (millis_len == 1) {
millis *= 100;
} else if (millis_len == 2) {
millis *= 10;
}
if (millis < 0 || millis > 1000) {
DATE_PARSE_ERR ("milliseconds must be at least 0 and less than 1000");
}
}
posix_date.tm_sec = sec;
posix_date.tm_min = min;
posix_date.tm_hour = hour;
posix_date.tm_mday = day;
posix_date.tm_mon = month;
posix_date.tm_year = year;
posix_date.tm_wday = 0;
posix_date.tm_yday = 0;
millis = 1000 * _bson_timegm (&posix_date) + millis;
millis += tz_adjustment * 1000;
*out = millis;
return true;
}
bool
_bson_iso8601_date_parse (const char *str,
int32_t len,
int64_t *out,
bson_error_t *error)
{
const char *ptr;
int32_t remaining = len;
const char *year_ptr;
const char *month_ptr;
const char *day_ptr;
const char *hour_ptr;
const char *min_ptr;
const char *sec_ptr;
const char *millis_ptr;
const char *tz_ptr;
int32_t year_len = 0;
int32_t month_len = 0;
int32_t day_len = 0;
int32_t hour_len = 0;
int32_t min_len = 0;
int32_t sec_len = 0;
int32_t millis_len = 0;
int32_t tz_len = 0;
int32_t year;
int32_t month;
int32_t day;
int32_t hour;
int32_t min;
int32_t sec = 0;
int64_t millis = 0;
int32_t tz_adjustment = 0;
#ifdef BSON_OS_WIN32
SYSTEMTIME win_sys_time;
FILETIME win_file_time;
int64_t win_time_offset;
int64_t win_epoch_difference;
#else
struct tm posix_date = {0};
#endif
#define DATE_PARSE_ERR(msg) \
bson_set_error (error, \
BSON_ERROR_JSON, \
BSON_JSON_ERROR_READ_INVALID_PARAM, \
"Could not parse \"%s\" as date: " msg, \
str); \
return false
#define DEFAULT_DATE_PARSE_ERR \
DATE_PARSE_ERR ("use ISO8601 format yyyy-mm-ddThh:mm plus timezone, either" \
" \"Z\" or like \"+0500\"")
ptr = str;
/* we have to match at least yyyy-mm-ddThh:mm */
if (!(get_tok ("-", &ptr, &remaining, &year_ptr, &year_len) &&
get_tok ("-", &ptr, &remaining, &month_ptr, &month_len) &&
get_tok ("T", &ptr, &remaining, &day_ptr, &day_len) &&
get_tok (":", &ptr, &remaining, &hour_ptr, &hour_len) &&
get_tok (":+-Z", &ptr, &remaining, &min_ptr, &min_len))) {
DEFAULT_DATE_PARSE_ERR;
}
/* if the minute has a ':' at the end look for seconds */
if (min_ptr[min_len] == ':') {
if (remaining < 2) {
DATE_PARSE_ERR ("reached end of date while looking for seconds");
}
get_tok (".+-Z", &ptr, &remaining, &sec_ptr, &sec_len);
if (!sec_len) {
DATE_PARSE_ERR ("minute ends in \":\" seconds is required");
}
}
/* if we had a second and it is followed by a '.' look for milliseconds */
if (sec_len && sec_ptr[sec_len] == '.') {
if (remaining < 2) {
DATE_PARSE_ERR ("reached end of date while looking for milliseconds");
}
get_tok ("+-Z", &ptr, &remaining, &millis_ptr, &millis_len);
if (!millis_len) {
DATE_PARSE_ERR ("seconds ends in \".\", milliseconds is required");
}
}
/* backtrack by 1 to put ptr on the timezone */
ptr--;
remaining++;
get_tok ("", &ptr, &remaining, &tz_ptr, &tz_len);
/* we want to include the last few hours in 1969 for timezones translate
* across 1970 GMT. We'll check in timegm later on to make sure we're post
* 1970 */
if (!parse_num (year_ptr, year_len, 4, 1969, 9999, &year)) {
DATE_PARSE_ERR ("year must be an integer");
}
/* values are as in struct tm */
year -= 1900;
if (!parse_num (month_ptr, month_len, 2, 1, 12, &month)) {
DATE_PARSE_ERR ("month must be an integer");
}
/* values are as in struct tm */
month -= 1;
if (!parse_num (day_ptr, day_len, 2, 1, 31, &day)) {
DATE_PARSE_ERR ("day must be an integer");
}
if (!parse_num (hour_ptr, hour_len, 2, 0, 23, &hour)) {
DATE_PARSE_ERR ("hour must be an integer");
}
if (!parse_num (min_ptr, min_len, 2, 0, 59, &min)) {
DATE_PARSE_ERR ("minute must be an integer");
}
if (sec_len && !parse_num (sec_ptr, sec_len, 2, 0, 60, &sec)) {
DATE_PARSE_ERR ("seconds must be an integer");
}
if (tz_len > 0) {
if (tz_ptr[0] == 'Z' && tz_len == 1) {
/* valid */
} else if (tz_ptr[0] == '+' || tz_ptr[0] == '-') {
int32_t tz_hour;
int32_t tz_min;
if (tz_len != 5 || !digits_only (tz_ptr + 1, 4)) {
DATE_PARSE_ERR ("could not parse timezone");
}
if (!parse_num (tz_ptr + 1, 2, -1, -23, 23, &tz_hour)) {
DATE_PARSE_ERR ("timezone hour must be at most 23");
}
if (!parse_num (tz_ptr + 3, 2, -1, 0, 59, &tz_min)) {
DATE_PARSE_ERR ("timezone minute must be at most 59");
}
/* we inflect the meaning of a 'positive' timezone. Those are hours
* we have to substract, and vice versa */
tz_adjustment =
(tz_ptr[0] == '-' ? 1 : -1) * ((tz_min * 60) + (tz_hour * 60 * 60));
if (!(tz_adjustment > -86400 && tz_adjustment < 86400)) {
DATE_PARSE_ERR ("timezone offset must be less than 24 hours");
}
} else {
DATE_PARSE_ERR ("timezone is required");
}
}
if (millis_len > 0) {
int i;
int magnitude;
millis = 0;
if (millis_len > 3 || !digits_only (millis_ptr, millis_len)) {
DATE_PARSE_ERR ("milliseconds must be an integer");
}
for (i = 1, magnitude = 1; i <= millis_len; i++, magnitude *= 10) {
millis += (millis_ptr[millis_len - i] - '0') * magnitude;
}
if (millis_len == 1) {
millis *= 100;
} else if (millis_len == 2) {
millis *= 10;
}
if (millis < 0 || millis > 1000) {
DATE_PARSE_ERR ("milliseconds must be at least 0 and less than 1000");
}
}
#ifdef BSON_OS_WIN32
win_sys_time.wMilliseconds = millis;
win_sys_time.wSecond = sec;
win_sys_time.wMinute = min;
win_sys_time.wHour = hour;
win_sys_time.wDay = day;
win_sys_time.wDayOfWeek = -1; /* ignored */
win_sys_time.wMonth = month + 1;
win_sys_time.wYear = year + 1900;
/* the wDayOfWeek member of SYSTEMTIME is ignored by this function */
if (SystemTimeToFileTime (&win_sys_time, &win_file_time) == 0) {
return 0;
}
/* The Windows FILETIME structure contains two parts of a 64-bit value
* representing the
* number of 100-nanosecond intervals since January 1, 1601
*/
win_time_offset = (((uint64_t) win_file_time.dwHighDateTime) << 32) |
win_file_time.dwLowDateTime;
/* There are 11644473600 seconds between the unix epoch and the windows epoch
* 100-nanoseconds = milliseconds * 10000
*/
win_epoch_difference = 11644473600000 * 10000;
/* removes the diff between 1970 and 1601 */
win_time_offset -= win_epoch_difference;
/* 1 milliseconds = 1000000 nanoseconds = 10000 100-nanosecond intervals */
millis = win_time_offset / 10000;
#else
posix_date.tm_sec = sec;
posix_date.tm_min = min;
posix_date.tm_hour = hour;
posix_date.tm_mday = day;
posix_date.tm_mon = month;
posix_date.tm_year = year;
posix_date.tm_wday = 0;
posix_date.tm_yday = 0;
millis = (1000 * ((uint64_t) _bson_timegm (&posix_date))) + millis;
#endif
millis += tz_adjustment * 1000;
if (millis < 0) {
DATE_PARSE_ERR ("must be after January 1, 1970");
}
*out = millis;
return true;
}
static jboolean
parseOptions(char *options)
{
TransportSpec *currentTransport = NULL;
char *end;
char *current;
int length;
char *str;
char *errmsg;
/* Set defaults */
gdata->assertOn = DEFAULT_ASSERT_ON;
gdata->assertFatal = DEFAULT_ASSERT_FATAL;
logfile = DEFAULT_LOGFILE;
/* Options being NULL will end up being an error. */
if (options == NULL) {
options = "";
}
/* Check for "help" BEFORE we add any environmental settings */
if ((strcmp(options, "help")) == 0) {
printUsage();
forceExit(0); /* Kill entire process, no core dump wanted */
}
/* These buffers are never freed */
{
char *envOptions;
/*
* Add environmentally specified options.
*/
envOptions = getenv("_JAVA_JDWP_OPTIONS");
if (envOptions != NULL) {
options = add_to_options(options, envOptions);
if ( options==NULL ) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options");
}
}
/*
* Allocate a buffer for names derived from option strings. It should
* never be longer than the original options string itself.
* Also keep a copy of the options in gdata->options.
*/
length = (int)strlen(options);
gdata->options = jvmtiAllocate(length + 1);
if (gdata->options == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options");
}
(void)strcpy(gdata->options, options);
names = jvmtiAllocate(length + 1);
if (names == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options");
}
transports = bagCreateBag(sizeof(TransportSpec), 3);
if (transports == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"transports");
}
}
current = names;
end = names + length;
str = options;
while (*str) {
char buf[100];
/*LINTED*/
if (!get_tok(&str, buf, (int)sizeof(buf), '=')) {
goto syntax_error;
}
if (strcmp(buf, "transport") == 0) {
currentTransport = bagAdd(transports);
/*LINTED*/
if (!get_tok(&str, current, (int)(end - current), ',')) {
goto syntax_error;
}
currentTransport->name = current;
current += strlen(current) + 1;
} else if (strcmp(buf, "address") == 0) {
if (currentTransport == NULL) {
errmsg = "address specified without transport";
goto bad_option_with_errmsg;
}
/*LINTED*/
if (!get_tok(&str, current, (int)(end - current), ',')) {
goto syntax_error;
}
currentTransport->address = current;
current += strlen(current) + 1;
} else if (strcmp(buf, "timeout") == 0) {
if (currentTransport == NULL) {
errmsg = "timeout specified without transport";
goto bad_option_with_errmsg;
}
/*LINTED*/
if (!get_tok(&str, current, (int)(end - current), ',')) {
goto syntax_error;
}
currentTransport->timeout = atol(current);
current += strlen(current) + 1;
} else if (strcmp(buf, "launch") == 0) {
/*LINTED*/
if (!get_tok(&str, current, (int)(end - current), ',')) {
goto syntax_error;
}
launchOnInit = current;
current += strlen(current) + 1;
} else if (strcmp(buf, "onthrow") == 0) {
/* Read class name and convert in place to a signature */
*current = 'L';
/*LINTED*/
if (!get_tok(&str, current + 1, (int)(end - current - 1), ',')) {
goto syntax_error;
}
initOnException = current;
while (*current != '\0') {
if (*current == '.') {
*current = '/';
}
current++;
}
*current++ = ';';
*current++ = '\0';
} else if (strcmp(buf, "assert") == 0) {
/*LINTED*/
if (!get_tok(&str, current, (int)(end - current), ',')) {
goto syntax_error;
}
if (strcmp(current, "y") == 0) {
gdata->assertOn = JNI_TRUE;
gdata->assertFatal = JNI_FALSE;
} else if (strcmp(current, "fatal") == 0) {
gdata->assertOn = JNI_TRUE;
gdata->assertFatal = JNI_TRUE;
} else if (strcmp(current, "n") == 0) {
gdata->assertOn = JNI_FALSE;
gdata->assertFatal = JNI_FALSE;
} else {
goto syntax_error;
}
current += strlen(current) + 1;
} else if (strcmp(buf, "pause") == 0) {
if ( !get_boolean(&str, &dopause) ) {
goto syntax_error;
}
if ( dopause ) {
do_pause();
}
} else if (strcmp(buf, "coredump") == 0) {
if ( !get_boolean(&str, &docoredump) ) {
goto syntax_error;
}
} else if (strcmp(buf, "errorexit") == 0) {
if ( !get_boolean(&str, &(gdata->doerrorexit)) ) {
goto syntax_error;
}
} else if (strcmp(buf, "exitpause") == 0) {
errmsg = "The exitpause option removed, use -XX:OnError";
goto bad_option_with_errmsg;
} else if (strcmp(buf, "precrash") == 0) {
errmsg = "The precrash option removed, use -XX:OnError";
goto bad_option_with_errmsg;
} else if (strcmp(buf, "logfile") == 0) {
/*LINTED*/
if (!get_tok(&str, current, (int)(end - current), ',')) {
goto syntax_error;
}
logfile = current;
current += strlen(current) + 1;
} else if (strcmp(buf, "logflags") == 0) {
/*LINTED*/
if (!get_tok(&str, current, (int)(end - current), ',')) {
goto syntax_error;
}
/*LINTED*/
logflags = (unsigned)strtol(current, NULL, 0);
} else if (strcmp(buf, "debugflags") == 0) {
/*LINTED*/
if (!get_tok(&str, current, (int)(end - current), ',')) {
goto syntax_error;
}
/*LINTED*/
gdata->debugflags = (unsigned)strtol(current, NULL, 0);
} else if ( strcmp(buf, "suspend")==0 ) {
if ( !get_boolean(&str, &suspendOnInit) ) {
goto syntax_error;
}
} else if ( strcmp(buf, "server")==0 ) {
if ( !get_boolean(&str, &isServer) ) {
goto syntax_error;
}
} else if ( strcmp(buf, "strict")==0 ) { /* Obsolete, but accept it */
if ( !get_boolean(&str, &isStrict) ) {
goto syntax_error;
}
} else if ( strcmp(buf, "quiet")==0 ) {
if ( !get_boolean(&str, &(gdata->quiet)) ) {
goto syntax_error;
}
} else if ( strcmp(buf, "onuncaught")==0 ) {
if ( !get_boolean(&str, &initOnUncaught) ) {
goto syntax_error;
}
} else if ( strcmp(buf, "mutf8")==0 ) {
if ( !get_boolean(&str, &(gdata->modifiedUtf8)) ) {
goto syntax_error;
}
} else if ( strcmp(buf, "stdalloc")==0 ) { /* Obsolete, but accept it */
if ( !get_boolean(&str, &useStandardAlloc) ) {
goto syntax_error;
}
} else {
goto syntax_error;
}
}
/* Setup logging now */
if ( logfile!=NULL ) {
setup_logging(logfile, logflags);
(void)atexit(&atexit_finish_logging);
}
if (bagSize(transports) == 0) {
errmsg = "no transport specified";
goto bad_option_with_errmsg;
}
/*
* TO DO: Remove when multiple transports are allowed. (replace with
* check below.
*/
if (bagSize(transports) > 1) {
errmsg = "multiple transports are not supported in this release";
goto bad_option_with_errmsg;
}
if (!isServer) {
jboolean specified = bagEnumerateOver(transports, checkAddress, NULL);
if (!specified) {
/* message already printed */
goto bad_option_no_msg;
}
}
/*
* The user has selected to wait for an exception before init happens
*/
if ((initOnException != NULL) || (initOnUncaught)) {
initOnStartup = JNI_FALSE;
if (launchOnInit == NULL) {
/*
* These rely on the launch=/usr/bin/foo
* suboption, so it is an error if user did not
* provide one.
*/
errmsg = "Specify launch=<command line> when using onthrow or onuncaught suboption";
goto bad_option_with_errmsg;
}
}
return JNI_TRUE;
syntax_error:
ERROR_MESSAGE(("JDWP option syntax error: %s=%s", AGENTLIB, options));
return JNI_FALSE;
bad_option_with_errmsg:
ERROR_MESSAGE(("JDWP %s: %s=%s", errmsg, AGENTLIB, options));
return JNI_FALSE;
bad_option_no_msg:
ERROR_MESSAGE(("JDWP %s: %s=%s", "invalid option", AGENTLIB, options));
return JNI_FALSE;
}
/*
* returns -1 if error, 0 if no users in realm, otherwise the number of users retrieved
* user: pointer to an array containing pointers to returned users - it's allocated within this function
* caller will free() the array after use
* buflen: lenght in bytes of returned buffer
* realm: specifies the realm; if NULL, the default realm will be used
*/
int sp_list_users (char ***user, const char *realm) {
int len, i;
char *r_ptr, **u_ptr, *u_str;
jsmntok_t *tok;
struct MemoryStruct chunk;
if ((sp_config.status != SP_INITED)) {
if (!(sp_init ())) return -1;
}
if (realm != NULL)
r_ptr = (char *) realm;
else
r_ptr = sp_config.realm;
char post_data[(strlen ("REALM=") + strlen (r_ptr) + 1)];
sprintf (post_data, "%s%s", "REALM=", r_ptr);
len = do_curl(sp_config.URL_u_list, post_data, &tok, (struct MemoryStruct *) &chunk);
if (len == -1) {
return -1;
}
if (!(rc_ok (chunk.memory, tok, len))) {
free (tok);
free (chunk.memory);
return -1;
}
/*
* Get array from JSON response
*/
int idx = get_tok (chunk.memory, tok, len, "username");
if (idx == -1) {
debug (1, "token \"username\" not found in JSON response");
free (tok);
free (chunk.memory);
return 0;
}
if (!(IS_ARRAY(tok[idx]))) {
debug (1, "pair of token \"username\" in JSON response is not an array");
free (tok);
free (chunk.memory);
return 0;
}
len = tok[idx].size;
idx++;
/*
* Allocate buffer to be returned and copy data to it. chunk.size is surely un upper bound to contain
* the user list
*/
int ptrs_size = (len * sizeof (char *));
int buflen = ptrs_size + chunk.size;
*user = (char **) malloc (buflen);
if (!(*user)) {
error ("malloc(%d) failed", buflen);
free (tok);
free (chunk.memory);
return -1;
}
for (i = idx, u_ptr=(char **) *user, u_str=((char *) *user + ptrs_size); i < (idx + len); i++) {
int l = tok[i].end - tok[i].start;
memcpy (u_str, chunk.memory + tok[i].start, l);
*(u_str + l) = 0;
*u_ptr = u_str;
u_str += l + 1;
u_ptr++;
}
free (tok);
free (chunk.memory);
return len;
}
V7_PRIVATE enum v7_tok lookahead(const struct v7 *v7) {
const char *s = v7->pstate.pc;
double d;
return get_tok(&s, &d);
}