char *interprut_request(char *request)
{
time_t rawtime;
struct tm * timeinfo;
time ( &rawtime );
timeinfo = localtime ( &rawtime );
if(str_starts_with(request, "timedate"))
{
strftime (buffer, MAX_BUFFER_SIZE, "%c", timeinfo);
return(buffer);
}
if(str_starts_with(request, "time"))
{
strftime (buffer, MAX_BUFFER_SIZE, "%X", timeinfo);
return(buffer);
}
if(str_starts_with(request, "date"))
{
strftime (buffer, MAX_BUFFER_SIZE, "%A %B %d %Y", timeinfo);
return(buffer);
}
if(str_starts_with(request, "quit"))
{
return("quit");
}
//else
return("Sorry, request was not understood\n");
}
/*
* Downloads file from url, installs in package database, return package name.
*/
int
opkg_prepare_url_for_install(const char *url, char **namep)
{
int err = 0;
pkg_t *pkg;
pkg = pkg_new();
if (str_starts_with(url, "http://")
|| str_starts_with(url, "ftp://")) {
char *tmp_file;
char *file_basec = xstrdup(url);
char *file_base = basename(file_basec);
sprintf_alloc(&tmp_file, "%s/%s", conf->tmp_dir, file_base);
err = opkg_download(url, tmp_file, NULL, NULL, 0);
if (err)
return err;
err = pkg_init_from_file(pkg, tmp_file);
if (err)
return err;
free(tmp_file);
free(file_basec);
} else if (strcmp(&url[strlen(url) - 4], OPKG_PKG_EXTENSION) == 0
|| strcmp(&url[strlen(url) - 4], IPKG_PKG_EXTENSION) == 0
|| strcmp(&url[strlen(url) - 4], DPKG_PKG_EXTENSION) == 0) {
err = pkg_init_from_file(pkg, url);
if (err)
return err;
opkg_msg(DEBUG2, "Package %s provided by hand (%s).\n",
pkg->name, pkg->local_filename);
pkg->provided_by_hand = 1;
} else {
pkg_deinit(pkg);
free(pkg);
return 0;
}
pkg->dest = conf->default_dest;
pkg->state_want = SW_INSTALL;
pkg->state_flag |= SF_PREFER;
hash_insert_pkg(pkg, 1);
if (namep) {
*namep = pkg->name;
}
return 0;
}
static int __internal_str_to_int(const char *str, unsigned f_char, unsigned l_char, unsigned base)
{
unsigned i = str_starts_with("-", str, f_char, l_char) ? 1 : 0, res = 0, len = l_char - f_char + 1;
for (;i + f_char <= l_char; i++) {
char c = str[i + f_char];
if (c >= 'A' && c <= 'Z')
c += 32;
res += __str_first_pos(INT_FORMAT, c) * __pow_basic(base, len - i - 1);
}
if (str_starts_with("-", str, f_char, l_char))
res = ~res + 1;
return res;
}
int main(int argc, char **argv) {
assert(false == str_starts_with("foo", "bar"));
assert(true == str_starts_with("hello", "hello"));
assert(true == str_starts_with("hello", "hell"));
assert(true == str_starts_with("hello", "hel"));
assert(true == str_starts_with("hello", "he"));
assert(true == str_starts_with("hello", "h"));
assert(false == str_starts_with("hello", "ello"));
assert(false == str_starts_with("hello", "llo"));
assert(false == str_starts_with("hello", "lo"));
assert(false == str_starts_with("hello", "o"));
return 0;
}
int str_to_int(const char *str, unsigned f_char, unsigned l_char)
{
unsigned res = -1;
if (str_starts_with("0x", str, f_char, l_char))
res = __internal_str_to_int(str, f_char + 2, l_char, 16);
else if (str_starts_with("0b", str, f_char, l_char))
res = __internal_str_to_int(str, f_char + 2, l_char, 2);
else if (str_first_pos(str, f_char, l_char, '.') == -1)
res = __internal_str_to_int(str, f_char, l_char, 10);
else {
float f = __internal_str_to_float(str, f_char, l_char);
res = *((int*)&f);
}
return res;
}
static float __internal_str_to_float(const char *str, unsigned f_char, unsigned l_char)
{
int i = str_starts_with("-", str, f_char, l_char) ? f_char + 1 : f_char, dotpos = 0;
float res = 0.0f;
for (; i <= l_char; i++) {
if (str[i] == '.')
dotpos = l_char - i;
else
res = res * 10.0 + (str[i] - '0');
}
while (dotpos--)
res /= 10.0f;
if (str_starts_with("-", str, f_char, l_char))
res *= -1;
return res;
}
char *
str_replace (const char *haystack, const char *needle, const char *replacement)
{
assert (haystack != NULL);
assert (needle != NULL);
assert (replacement != NULL);
string_buffer_t *sb = string_buffer_create ();
size_t haystack_len = strlen (haystack);
size_t needle_len = strlen (needle);
int pos = 0;
while (pos < haystack_len) {
if (needle_len > 0 && str_starts_with (&haystack[pos], needle)) {
string_buffer_append_string (sb, replacement);
pos += needle_len;
}
else {
string_buffer_append (sb, haystack[pos]);
pos++;
}
}
if (needle_len == 0 && haystack_len == 0)
string_buffer_append_string (sb, replacement);
char *res = string_buffer_to_string (sb);
string_buffer_destroy (sb);
return res;
}
Module::Module(Script* s, const std::string& cls, const std::string& id) : script(s), cls(cls),id(id) {
the_script = 0;
bProcessable = true;
used = 0;
thread = 0;
nb_no_async_ins = 0;
if(str_starts_with(cls, "In<")) bProcessable = false;
}
int main()
{
int sckt, portnum, newsckt, clisize, status;
struct sockaddr_in servadd, cliadd;
//open socket
sckt = socket(AF_INET, SOCK_STREAM, 0);
if(sckt < 0)
{
printf("ERROR: Could not open socket\n");
}
//bind the port
portnum = 4502;
servadd.sin_family = AF_INET;
servadd.sin_addr.s_addr = INADDR_ANY;
servadd.sin_port = htons(portnum);
if(bind(sckt, (struct sockaddr *) &servadd, sizeof(servadd)) < 0)
printf("ERROR: Could not bind!\n");
while(1)
{
//listen
listen(sckt, 5);
//accept connection on socket
clisize = sizeof(cliadd);
printf("Waiting for client connection...\n");
newsckt = accept(sckt, (struct sockaddr *) &cliadd, &clisize);
if(newsckt < 0)
printf("ERROR: Could not accept!\n");
//read message from client
status = recv(newsckt, buffer, MAX_BUFFER_SIZE, 0);
if(status < 0)
printf("ERROR: Could not read from socket\n");
printf("Client send message: %s\n", buffer);
char *message;
message = interprut_request(buffer);
//message = "Message recieved";
printf("Sending response: %s\n", message);
status = send(newsckt, message, strlen(message), 0);
if(str_starts_with(message, "quit"))
{
exit(0);
}
if(status < 0)
printf("ERROR: Could not write to socket\n");
set_buffer_empty();
}
return(0);
}
// Return type of entry
static dbentry_type get_modelfamily_type(const char * modelfamily)
{
if (modelfamily[0] == 'D' && !strcmp(modelfamily, "DEFAULT"))
return DBENTRY_ATA_DEFAULT;
else if(modelfamily[0] == 'U' && str_starts_with(modelfamily, "USB:"))
return DBENTRY_USB;
else
return DBENTRY_ATA;
}
static int
opkg_download_cache(const char *src, const char *dest_file_name,
curl_progress_func cb, void *data)
{
char *cache_name = xstrdup(src);
char *cache_location, *p;
int err = 0;
if (!conf->cache || str_starts_with(src, "file:")) {
err = opkg_download(src, dest_file_name, cb, data, 0);
goto out1;
}
if(!file_is_dir(conf->cache)){
opkg_msg(ERROR, "%s is not a directory.\n",
conf->cache);
err = 1;
goto out1;
}
for (p = cache_name; *p; p++)
if (*p == '/')
*p = ','; /* looks nicer than | or # */
sprintf_alloc(&cache_location, "%s/%s", conf->cache, cache_name);
if (file_exists(cache_location))
opkg_msg(NOTICE, "Copying %s.\n", cache_location);
else {
/* cache file with funky name not found, try simple name */
free(cache_name);
char *filename = strrchr(dest_file_name,'/');
if (filename)
cache_name = xstrdup(filename+1); // strip leading '/'
else
cache_name = xstrdup(dest_file_name);
free(cache_location);
sprintf_alloc(&cache_location, "%s/%s", conf->cache, cache_name);
if (file_exists(cache_location))
opkg_msg(NOTICE, "Copying %s.\n", cache_location);
else {
err = opkg_download(src, cache_location, cb, data, 0);
if (err) {
(void) unlink(cache_location);
goto out2;
}
}
}
err = file_copy(cache_location, dest_file_name);
out2:
free(cache_location);
out1:
free(cache_name);
return err;
}
bool
string_feeder_starts_with (string_feeder_t *sf, const char *str)
{
assert (sf != NULL);
assert (str != NULL);
assert (sf->pos <= sf->len);
return str_starts_with (&sf->s[sf->pos], str);
}
int HTTPExchange_read_response_headers(HTTPExchange * exchange) {
/* make sure the request went through before we try to read stuff */
int result = HTTPExchange_flush_request(exchange);
if (result != 0) {
return result;
}
result = HTTPMessage_read_start_line_and_headers(exchange->response_message);
if (result != 0) {
return result;
}
/* parse the Status-Line (RFC 2616 6.1) */
const char * status_line = HTTPMessage_get_start_line(exchange->response_message);
const char * p = status_line;
/* read the HTTP-Version */
if (! str_starts_with(p, "HTTP/")) {
return -1;
}
p += 5;
const char * start = p;
skip_digits(&p);
if (start == p) {
return -1;
}
if (*p != '.') {
return -1;
}
p++;
start = p;
skip_digits(&p);
if (start == p) {
return -1;
}
if (*p != ' ') {
return -1;
}
exchange->response_http_version = xstrndup(status_line, p - status_line);
/* skip over the space */
p++;
/* read the Status-Code */
start = p;
skip_digits(&p);
if (p - start != 3) {
return -1;
}
if (*p != ' ') {
return -1;
}
exchange->status_code = strtoul(start, NULL, 10);
return 0;
}
//tells us the index that we will use for the argument... arguments
int find_arg_element(char **argv, int argc)
{
int i;
for(i = 0; i < argc; i++)
{
if(str_starts_with(argv[i], "-"))
return(i);
}
return(-1);
}
//return the index of the first argv that is not led by a dash
int find_dir_element(char **argv, int argc)
{
int i;
for(i = 1; i < argc; i++)
{
if((str_starts_with(argv[i], "-")) == 0)
return(i);
}
return(-1);
}
bool
str_starts_with_any (const char *haystack, const char **needles, int num_needles)
{
assert (haystack != NULL);
assert (needles != NULL);
assert (num_needles >= 0);
for (int i = 0; i < num_needles; i++) {
assert (needles[i] != NULL);
if (str_starts_with (haystack, needles[i]))
return true;
}
return false;
}
/*
* jenkins_color_atoi() - converts a string status to its traffic light counterpart.
*
* @color: A string with a jenkins color status.
*
* Converts a string denoting a status of a jenkins job to its numeric
* led status counterpart.
*/
int jenkins_color_to_led(const char* color)
{
int status = 0;
if (str_starts_with(color, "blue")) status = LED_GREEN;
if (str_starts_with(color, "yellow")) status = LED_ORANGE;
if (str_starts_with(color, "red")) status = LED_RED;
if (str_starts_with(color, "disabled")) status = LED_OFF;
if (str_starts_with(color, "grey")) status = LED_GREEN | LED_ORANGE | LED_RED | LED_BLINKING;
if (str_starts_with(color, "aborted")) status = LED_OFF;
if (str_ends_with(color, "anime")) status |= LED_BLINKING;
return status;
}
void TestUtilities::testStartsWith()
{
UASSERT(str_starts_with(std::string(), std::string()) == true);
UASSERT(str_starts_with(std::string("the sharp pickaxe"),
std::string()) == true);
UASSERT(str_starts_with(std::string("the sharp pickaxe"),
std::string("the")) == true);
UASSERT(str_starts_with(std::string("the sharp pickaxe"),
std::string("The")) == false);
UASSERT(str_starts_with(std::string("the sharp pickaxe"),
std::string("The"), true) == true);
UASSERT(str_starts_with(std::string("T"), std::string("The")) == false);
}
int pkg_dest_init(pkg_dest_t *dest, const char *name, const char *root_dir,const char * lists_dir, ipkg_conf_t *conf)
{
dest->name = strdup(name);
/* Guarantee that dest->root_dir ends with a '/' */
if (str_ends_with(root_dir, "/")) {
dest->root_dir = strdup(root_dir);
} else {
sprintf_alloc(&dest->root_dir, "%s/", root_dir);
}
file_mkdir_hier(dest->root_dir, 0755);
if (!conf->ipkg_libdir) {
sprintf_alloc(&dest->ipkg_dir, "%s%s",
dest->root_dir, IPKG_STATE_DIR_PREFIX);
}else{
sprintf_alloc(&dest->ipkg_dir, "%s%s",
dest->root_dir, conf->ipkg_libdir);
}
file_mkdir_hier(dest->ipkg_dir, 0755);
if (str_starts_with (lists_dir, "/"))
sprintf_alloc(&dest->lists_dir, "%s", lists_dir);
else
sprintf_alloc(&dest->lists_dir, "/%s", lists_dir);
file_mkdir_hier(dest->lists_dir, 0755);
sprintf_alloc(&dest->info_dir, "%s/%s",
dest->ipkg_dir, IPKG_INFO_DIR_SUFFIX);
file_mkdir_hier(dest->info_dir, 0755);
sprintf_alloc(&dest->status_file_name, "%s/%s",
dest->ipkg_dir, IPKG_STATUS_FILE_SUFFIX);
sprintf_alloc(&dest->status_file_tmp_name, "%s/%s.tmp",
dest->ipkg_dir, IPKG_STATUS_FILE_SUFFIX);
dest->status_file = NULL;
return 0;
}
zarray_t *
str_split (const char *str, const char *delim)
{
assert (str != NULL);
assert (delim != NULL);
zarray_t *parts = zarray_create (sizeof(char*));
string_buffer_t *sb = string_buffer_create ();
size_t delim_len = strlen (delim);
size_t len = strlen (str);
size_t pos = 0;
while (pos < len) {
if (str_starts_with (&str[pos], delim) && delim_len > 0) {
pos += delim_len;
// never add empty strings (repeated tokens)
if (string_buffer_size (sb) > 0) {
char *part = string_buffer_to_string (sb);
zarray_add (parts, &part);
}
string_buffer_reset (sb);
}
else {
string_buffer_append (sb, str[pos]);
pos++;
}
}
if (string_buffer_size(sb) > 0) {
char *part = string_buffer_to_string (sb);
zarray_add (parts, &part);
}
string_buffer_destroy (sb);
return parts;
}
int workerpool_get_nprocs()
{
FILE * f = fopen("/proc/cpuinfo", "r");
size_t n = 0;
char * buf = NULL;
int nproc = 0;
while(getline(&buf, &n, f) != -1)
{
if(!str_starts_with(buf, "processor"))
continue;
int colon = str_indexof(buf, ":");
int v = atoi(&buf[colon+1]);
if (v > nproc)
nproc = v;
}
free(buf);
return nproc;
}
int HTTPExchange_write_request_headers(HTTPExchange * exchange) {
if (HTTPMessage_has_sent_headers(exchange->request_message)) {
return 0;
}
/* set the Request-Line */
if (HTTPMessage_get_start_line(exchange->request_message) == NULL) {
if (exchange->method == NULL) {
exchange->method = xstrdup("GET");
}
assert(exchange->request_uri != NULL);
char * request_line;
xasprintf(&request_line, "%s %s HTTP/1.1\r\n", exchange->method, exchange->request_uri);
HTTPMessage_set_start_line(exchange->request_message, request_line);
free(request_line);
}
/* set the Host, if necessary */
if (! str_starts_with(exchange->request_uri, "http://")) {
const char * host = HTTPMessage_find_header(exchange->request_message, HTTP_HOST);
if (host == NULL) {
struct sockaddr_in peer;
int result = HTTPConnection_get_peer(exchange->connection, &peer);
if (result != 0) {
return result;
}
const char * a = inet_ntoa(peer.sin_addr);
char * value;
xasprintf(&value, "%s:%u", a, ntohs(peer.sin_port));
HTTPMessage_add_header(exchange->request_message, HTTP_HOST, value);
free(value);
}
}
return HTTPMessage_write_start_line_and_headers(exchange->request_message);
}
/**
* Read in a Viking file and return how successful the parsing was
* ATM this will always work, in that even if there are parsing problems
* then there will be no new values to override the defaults
*
* TODO flow up line number(s) / error messages of problems encountered...
*
*/
static gboolean file_read ( VikAggregateLayer *top, FILE *f, const gchar *dirpath, VikViewport *vp )
{
Stack *stack;
struct LatLon ll = { 0.0, 0.0 };
gchar buffer[4096];
gchar *line;
guint16 len;
long line_num = 0;
VikLayerParam *params = NULL; /* for current layer, so we don't have to keep on looking up interface */
guint8 params_count = 0;
GHashTable *string_lists = g_hash_table_new(g_direct_hash,g_direct_equal);
gboolean successful_read = TRUE;
push(&stack);
stack->under = NULL;
stack->data = (gpointer) top;
while ( fgets ( buffer, 4096, f ) )
{
line_num++;
line = buffer;
while ( *line == ' ' || *line =='\t' )
line++;
if ( line[0] == '#' )
continue;
len = strlen(line);
if ( len > 0 && line[len-1] == '\n' )
line[--len] = '\0';
if ( len > 0 && line[len-1] == '\r' )
line[--len] = '\0';
if ( len == 0 )
continue;
if ( line[0] == '~' )
{
line++; len--;
if ( *line == '\0' )
continue;
else if ( str_starts_with ( line, "Layer ", 6, TRUE ) )
{
int parent_type = VIK_LAYER(stack->data)->type;
if ( ( ! stack->data ) || ((parent_type != VIK_LAYER_AGGREGATE) && (parent_type != VIK_LAYER_GPS)) )
{
successful_read = FALSE;
g_warning ( "Line %ld: Layer command inside non-Aggregate Layer (type %d)", line_num, parent_type );
push(&stack); /* inside INVALID layer */
stack->data = NULL;
continue;
}
else
{
VikLayerTypeEnum type = vik_layer_type_from_string ( line+6 );
push(&stack);
if ( type == VIK_LAYER_NUM_TYPES )
{
successful_read = FALSE;
g_warning ( "Line %ld: Unknown type %s", line_num, line+6 );
stack->data = NULL;
}
else if (parent_type == VIK_LAYER_GPS)
{
stack->data = (gpointer) vik_gps_layer_get_a_child(VIK_GPS_LAYER(stack->under->data));
params = vik_layer_get_interface(type)->params;
params_count = vik_layer_get_interface(type)->params_count;
}
else
{
stack->data = (gpointer) vik_layer_create ( type, vp, FALSE );
params = vik_layer_get_interface(type)->params;
params_count = vik_layer_get_interface(type)->params_count;
}
}
}
else if ( str_starts_with ( line, "EndLayer", 8, FALSE ) )
{
if ( stack->under == NULL ) {
successful_read = FALSE;
g_warning ( "Line %ld: Mismatched ~EndLayer command", line_num );
}
else
{
/* add any string lists we've accumulated */
gpointer layer_and_vp[2];
layer_and_vp[0] = stack->data;
layer_and_vp[1] = vp;
g_hash_table_foreach ( string_lists, (GHFunc) string_list_set_param, layer_and_vp );
g_hash_table_remove_all ( string_lists );
if ( stack->data && stack->under->data )
{
if (VIK_LAYER(stack->under->data)->type == VIK_LAYER_AGGREGATE) {
vik_aggregate_layer_add_layer ( VIK_AGGREGATE_LAYER(stack->under->data), VIK_LAYER(stack->data), FALSE );
vik_layer_post_read ( VIK_LAYER(stack->data), vp, TRUE );
}
else if (VIK_LAYER(stack->under->data)->type == VIK_LAYER_GPS) {
/* TODO: anything else needs to be done here ? */
}
else {
successful_read = FALSE;
g_warning ( "Line %ld: EndLayer command inside non-Aggregate Layer (type %d)", line_num, VIK_LAYER(stack->data)->type );
}
}
pop(&stack);
}
}
else if ( str_starts_with ( line, "LayerData", 9, FALSE ) )
{
if ( stack->data && vik_layer_get_interface(VIK_LAYER(stack->data)->type)->read_file_data )
{
/* must read until hits ~EndLayerData */
if ( ! vik_layer_get_interface(VIK_LAYER(stack->data)->type)->read_file_data ( VIK_LAYER(stack->data), f, dirpath ) )
successful_read = FALSE;
}
else
{ /* simply skip layer data over */
while ( fgets ( buffer, 4096, f ) )
{
line_num++;
line = buffer;
len = strlen(line);
if ( len > 0 && line[len-1] == '\n' )
line[--len] = '\0';
if ( len > 0 && line[len-1] == '\r' )
line[--len] = '\0';
if ( strcasecmp ( line, "~EndLayerData" ) == 0 )
break;
}
continue;
}
}
else
{
successful_read = FALSE;
g_warning ( "Line %ld: Unknown tilde command", line_num );
}
}
else
{
gint32 eq_pos = -1;
guint16 i;
if ( ! stack->data )
continue;
for ( i = 0; i < len; i++ )
if ( line[i] == '=' )
eq_pos = i;
if ( stack->under == NULL && eq_pos == 12 && strncasecmp ( line, "FILE_VERSION", eq_pos ) == 0) {
gint version = strtol(line+13, NULL, 10);
g_debug ( "%s: reading file version %d", __FUNCTION__, version );
if ( version > VIKING_FILE_VERSION )
successful_read = FALSE;
// However we'll still carry and attempt to read whatever we can
}
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "xmpp", eq_pos ) == 0) /* "hard coded" params: global & for all layer-types */
vik_viewport_set_xmpp ( VIK_VIEWPORT(vp), strtod ( line+5, NULL ) );
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "ympp", eq_pos ) == 0)
vik_viewport_set_ympp ( VIK_VIEWPORT(vp), strtod ( line+5, NULL ) );
else if ( stack->under == NULL && eq_pos == 3 && strncasecmp ( line, "lat", eq_pos ) == 0 )
ll.lat = strtod ( line+4, NULL );
else if ( stack->under == NULL && eq_pos == 3 && strncasecmp ( line, "lon", eq_pos ) == 0 )
ll.lon = strtod ( line+4, NULL );
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "utm" ) == 0)
vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_UTM);
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "expedia" ) == 0)
vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_EXPEDIA );
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "google" ) == 0)
{
successful_read = FALSE;
g_warning ( _("Draw mode '%s' no more supported"), "google" );
}
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "kh" ) == 0)
{
successful_read = FALSE;
g_warning ( _("Draw mode '%s' no more supported"), "kh" );
}
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "mercator" ) == 0)
vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_MERCATOR );
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "latlon" ) == 0)
vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_LATLON );
else if ( stack->under == NULL && eq_pos == 5 && strncasecmp ( line, "color", eq_pos ) == 0 )
vik_viewport_set_background_color ( VIK_VIEWPORT(vp), line+6 );
else if ( stack->under == NULL && eq_pos == 14 && strncasecmp ( line, "highlightcolor", eq_pos ) == 0 )
vik_viewport_set_highlight_color ( VIK_VIEWPORT(vp), line+15 );
else if ( stack->under == NULL && eq_pos == 9 && strncasecmp ( line, "drawscale", eq_pos ) == 0 )
vik_viewport_set_draw_scale ( VIK_VIEWPORT(vp), TEST_BOOLEAN(line+10) );
else if ( stack->under == NULL && eq_pos == 14 && strncasecmp ( line, "drawcentermark", eq_pos ) == 0 )
vik_viewport_set_draw_centermark ( VIK_VIEWPORT(vp), TEST_BOOLEAN(line+15) );
else if ( stack->under == NULL && eq_pos == 13 && strncasecmp ( line, "drawhighlight", eq_pos ) == 0 )
vik_viewport_set_draw_highlight ( VIK_VIEWPORT(vp), TEST_BOOLEAN(line+14) );
else if ( stack->under && eq_pos == 4 && strncasecmp ( line, "name", eq_pos ) == 0 )
vik_layer_rename ( VIK_LAYER(stack->data), line+5 );
else if ( eq_pos == 7 && strncasecmp ( line, "visible", eq_pos ) == 0 )
VIK_LAYER(stack->data)->visible = TEST_BOOLEAN(line+8);
else if ( eq_pos != -1 && stack->under )
{
gboolean found_match = FALSE;
/* go thru layer params. if len == eq_pos && starts_with jazz, set it. */
/* also got to check for name and visible. */
if ( ! params )
{
successful_read = FALSE;
g_warning ( "Line %ld: No options for this kind of layer", line_num );
continue;
}
for ( i = 0; i < params_count; i++ )
if ( strlen(params[i].name) == eq_pos && strncasecmp ( line, params[i].name, eq_pos ) == 0 )
{
VikLayerParamData x;
line += eq_pos+1;
if ( params[i].type == VIK_LAYER_PARAM_STRING_LIST ) {
GList *l = g_list_append ( g_hash_table_lookup ( string_lists, GINT_TO_POINTER ((gint) i) ),
g_strdup(line) );
g_hash_table_replace ( string_lists, GINT_TO_POINTER ((gint)i), l );
/* add the value to a list, possibly making a new list.
* this will be passed to the layer when we read an ~EndLayer */
} else {
switch ( params[i].type )
{
case VIK_LAYER_PARAM_DOUBLE: x.d = strtod(line, NULL); break;
case VIK_LAYER_PARAM_UINT: x.u = strtoul(line, NULL, 10); break;
case VIK_LAYER_PARAM_INT: x.i = strtol(line, NULL, 10); break;
case VIK_LAYER_PARAM_BOOLEAN: x.b = TEST_BOOLEAN(line); break;
case VIK_LAYER_PARAM_COLOR: memset(&(x.c), 0, sizeof(x.c)); /* default: black */
gdk_color_parse ( line, &(x.c) ); break;
/* STRING or STRING_LIST -- if STRING_LIST, just set param to add a STRING */
default: x.s = line;
}
vik_layer_set_param ( VIK_LAYER(stack->data), i, x, vp, TRUE );
}
found_match = TRUE;
break;
}
if ( ! found_match ) {
// ATM don't flow up this issue because at least one internal parameter has changed from version 1.3
// and don't what to worry users about raising such issues
// TODO Maybe hold old values here - compare the line value against them and if a match
// generate a different style of message in the GUI...
// successful_read = FALSE;
g_warning ( "Line %ld: Unknown parameter. Line:\n%s", line_num, line );
}
}
else {
successful_read = FALSE;
g_warning ( "Line %ld: Invalid parameter or parameter outside of layer.", line_num );
}
}
/* could be:
[Layer Type=Bla]
[EndLayer]
[LayerData]
name=this
#comment
*/
}
while ( stack )
{
if ( stack->under && stack->under->data && stack->data )
{
vik_aggregate_layer_add_layer ( VIK_AGGREGATE_LAYER(stack->under->data), VIK_LAYER(stack->data), FALSE );
vik_layer_post_read ( VIK_LAYER(stack->data), vp, TRUE );
}
pop(&stack);
}
if ( ll.lat != 0.0 || ll.lon != 0.0 )
vik_viewport_set_center_latlon ( VIK_VIEWPORT(vp), &ll, TRUE );
if ( ( ! VIK_LAYER(top)->visible ) && VIK_LAYER(top)->realized )
vik_treeview_item_set_visible ( VIK_LAYER(top)->vt, &(VIK_LAYER(top)->iter), FALSE );
/* delete anything we've forgotten about -- should only happen when file ends before an EndLayer */
g_hash_table_foreach ( string_lists, string_list_delete, NULL );
g_hash_table_destroy ( string_lists );
return successful_read;
}
static int is_unseen_set(struct dir_item *item)
{
return (str_starts_with(base_name(item->path), "set-") &&
str_ends_with(item->path, ".txt") &&
!set_is_loaded(item->path));
}
bool entity_is_drop(entity_t *source) {
return str_starts_with(source->class_name, "drop");
}
static int ntrip_sourcetable_parse(struct gps_device_t *device)
{
struct ntrip_stream_t hold;
ssize_t llen, len = 0;
char *line;
bool sourcetable = false;
bool match = false;
char buf[BUFSIZ];
size_t blen = sizeof(buf);
int fd = device->gpsdata.gps_fd;
for (;;) {
char *eol;
ssize_t rlen;
memset(&buf[len], 0, (size_t) (blen - len));
rlen = read(fd, &buf[len], (size_t) (blen - 1 - len));
if (rlen == -1) {
if (errno == EINTR) {
continue;
}
if (sourcetable && !match && errno == EAGAIN) { // we have not yet found a match, but there currently is no more data
return 0;
}
if (match) {
return 1;
}
gpsd_log(&device->context->errout, LOG_ERROR,
"ntrip stream read error %d on fd %d\n",
errno, fd);
return -1;
} else if (rlen == 0) { // server closed the connection
gpsd_log(&device->context->errout, LOG_ERROR,
"ntrip stream unexpected close %d on fd %d during sourcetable read\n",
errno, fd);
return -1;
}
line = buf;
rlen = len += rlen;
gpsd_log(&device->context->errout, LOG_RAW,
"Ntrip source table buffer %s\n", buf);
sourcetable = device->ntrip.sourcetable_parse;
if (!sourcetable) {
/* parse SOURCETABLE */
if (str_starts_with(line, NTRIP_SOURCETABLE)) {
sourcetable = true;
device->ntrip.sourcetable_parse = true;
llen = (ssize_t) strlen(NTRIP_SOURCETABLE);
line += llen;
len -= llen;
} else {
gpsd_log(&device->context->errout, LOG_WARN,
"Received unexpexted Ntrip reply %s.\n",
buf);
return -1;
}
}
while (len > 0) {
/* parse ENDSOURCETABLE */
if (str_starts_with(line, NTRIP_ENDSOURCETABLE))
goto done;
/* coverity[string_null] - nul-terminated by previous memset */
if (!(eol = strstr(line, NTRIP_BR)))
break;
gpsd_log(&device->context->errout, LOG_DATA,
"next Ntrip source table line %s\n", line);
*eol = '\0';
llen = (ssize_t) (eol - line);
/* todo: parse headers */
/* parse STR */
if (str_starts_with(line, NTRIP_STR)) {
ntrip_str_parse(line + strlen(NTRIP_STR),
(size_t) (llen - strlen(NTRIP_STR)),
&hold, &device->context->errout);
if (strcmp(device->ntrip.stream.mountpoint, hold.mountpoint) == 0) {
/* todo: support for RTCM 3.0, SBAS (WAAS, EGNOS), ... */
if (hold.format == fmt_unknown) {
gpsd_log(&device->context->errout, LOG_ERROR,
"Ntrip stream %s format not supported\n",
line);
return -1;
}
/* todo: support encryption and compression algorithms */
if (hold.compr_encryp != cmp_enc_none) {
gpsd_log(&device->context->errout, LOG_ERROR,
"Ntrip stream %s compression/encryption algorithm not supported\n",
line);
return -1;
}
/* todo: support digest authentication */
if (hold.authentication != auth_none
&& hold.authentication != auth_basic) {
gpsd_log(&device->context->errout, LOG_ERROR,
"Ntrip stream %s authentication method not supported\n",
line);
return -1;
}
/* no memcpy, so we can keep the other infos */
device->ntrip.stream.format = hold.format;
device->ntrip.stream.carrier = hold.carrier;
device->ntrip.stream.latitude = hold.latitude;
device->ntrip.stream.longitude = hold.longitude;
device->ntrip.stream.nmea = hold.nmea;
device->ntrip.stream.compr_encryp = hold.compr_encryp;
device->ntrip.stream.authentication = hold.authentication;
device->ntrip.stream.fee = hold.fee;
device->ntrip.stream.bitrate = hold.bitrate;
device->ntrip.stream.set = true;
match = true;
}
/* todo: compare stream location to own location to
* find nearest stream if user hasn't provided one */
}
/* todo: parse CAS */
/* else if (str_starts_with(line, NTRIP_CAS)); */
/* todo: parse NET */
/* else if (str_starts_with(line, NTRIP_NET)); */
llen += strlen(NTRIP_BR);
line += llen;
len -= llen;
gpsd_log(&device->context->errout, LOG_RAW,
"Remaining Ntrip source table buffer %zd %s\n", len,
line);
}
/* message too big to fit into buffer */
if ((size_t)len == blen - 1)
return -1;
if (len > 0)
memmove(buf, &buf[rlen - len], (size_t) len);
}
done:
return match ? 1 : -1;
}
int
opkg_download(const char *src, const char *dest_file_name,
curl_progress_func cb, void *data, const short hide_error)
{
int err = 0;
char *src_basec = xstrdup(src);
char *src_base = basename(src_basec);
char *tmp_file_location;
opkg_msg(NOTICE,"Downloading %s.\n", src);
if (str_starts_with(src, "file:")) {
const char *file_src = src + 5;
opkg_msg(INFO, "Copying %s to %s...", file_src, dest_file_name);
err = file_copy(file_src, dest_file_name);
opkg_msg(INFO, "Done.\n");
free(src_basec);
return err;
}
sprintf_alloc(&tmp_file_location, "%s/%s", conf->tmp_dir, src_base);
free(src_basec);
err = unlink(tmp_file_location);
if (err && errno != ENOENT) {
opkg_perror(ERROR, "Failed to unlink %s", tmp_file_location);
free(tmp_file_location);
return -1;
}
if (conf->http_proxy) {
opkg_msg(DEBUG, "Setting environment variable: http_proxy = %s.\n",
conf->http_proxy);
setenv("http_proxy", conf->http_proxy, 1);
}
if (conf->ftp_proxy) {
opkg_msg(DEBUG, "Setting environment variable: ftp_proxy = %s.\n",
conf->ftp_proxy);
setenv("ftp_proxy", conf->ftp_proxy, 1);
}
if (conf->no_proxy) {
opkg_msg(DEBUG,"Setting environment variable: no_proxy = %s.\n",
conf->no_proxy);
setenv("no_proxy", conf->no_proxy, 1);
}
#ifdef HAVE_CURL
CURLcode res;
FILE * file = fopen (tmp_file_location, "w");
curl = opkg_curl_init (cb, data);
if (curl)
{
curl_easy_setopt (curl, CURLOPT_URL, src);
curl_easy_setopt (curl, CURLOPT_WRITEDATA, file);
res = curl_easy_perform (curl);
fclose (file);
if (res)
{
long error_code;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &error_code);
opkg_msg(hide_error?DEBUG2:ERROR, "Failed to download %s: %s.\n",
src, curl_easy_strerror(res));
free(tmp_file_location);
return -1;
}
}
else
{
free(tmp_file_location);
return -1;
}
#else
{
int res;
const char *argv[8];
int i = 0;
argv[i++] = "wget";
argv[i++] = "-q";
if (conf->http_proxy || conf->ftp_proxy) {
argv[i++] = "-Y";
argv[i++] = "on";
}
argv[i++] = "-O";
argv[i++] = tmp_file_location;
argv[i++] = src;
argv[i++] = NULL;
res = xsystem(argv);
if (res) {
opkg_msg(ERROR, "Failed to download %s, wget returned %d.\n", src, res);
free(tmp_file_location);
return -1;
}
}
#endif
err = file_move(tmp_file_location, dest_file_name);
free(tmp_file_location);
return err;
}
int json_read_array(const char *cp, const struct json_array_t *arr,
const char **end)
{
int substatus, offset, arrcount;
char *tp;
if (end != NULL)
*end = NULL; /* give it a well-defined value on parse failure */
json_debug_trace((1, "Entered json_read_array()\n"));
while (isspace((unsigned char) *cp))
cp++;
if (*cp != '[') {
json_debug_trace((1, "Didn't find expected array start\n"));
return JSON_ERR_ARRAYSTART;
} else
cp++;
tp = arr->arr.strings.store;
arrcount = 0;
/* Check for empty array */
while (isspace((unsigned char) *cp))
cp++;
if (*cp == ']')
goto breakout;
for (offset = 0; offset < arr->maxlen; offset++) {
#ifndef JSON_MINIMAL
char *ep = NULL;
#endif /* JSON_MINIMAL */
json_debug_trace((1, "Looking at %s\n", cp));
switch (arr->element_type) {
case t_string:
if (isspace((unsigned char) *cp))
cp++;
if (*cp != '"')
return JSON_ERR_BADSTRING;
else
++cp;
arr->arr.strings.ptrs[offset] = tp;
for (; tp - arr->arr.strings.store < arr->arr.strings.storelen;
tp++)
if (*cp == '"') {
++cp;
*tp++ = '\0';
goto stringend;
} else if (*cp == '\0') {
json_debug_trace((1,
"Bad string syntax in string list.\n"));
return JSON_ERR_BADSTRING;
} else {
*tp = *cp++;
}
json_debug_trace((1, "Bad string syntax in string list.\n"));
return JSON_ERR_BADSTRING;
stringend:
break;
case t_object:
case t_structobject:
substatus =
json_internal_read_object(cp, arr->arr.objects.subtype, arr,
offset, &cp);
if (substatus != 0) {
#ifndef JSON_MINIMAL
if (end != NULL)
end = &cp;
#endif /* JSON_MINIMAL */
return substatus;
}
break;
case t_integer:
#ifndef JSON_MINIMAL
arr->arr.integers.store[offset] = (int)strtol(cp, &ep, 0);
if (ep == cp)
return JSON_ERR_BADNUM;
else
cp = ep;
break;
#endif /* JSON_MINIMAL */
case t_uinteger:
#ifndef JSON_MINIMAL
arr->arr.uintegers.store[offset] = (unsigned int)strtoul(cp, &ep, 0);
if (ep == cp)
return JSON_ERR_BADNUM;
else
cp = ep;
break;
#endif /* JSON_MINIMAL */
case t_short:
#ifndef JSON_MINIMAL
arr->arr.shorts.store[offset] = (short)strtol(cp, &ep, 0);
if (ep == cp)
return JSON_ERR_BADNUM;
else
cp = ep;
break;
#endif /* JSON_MINIMAL */
case t_ushort:
#ifndef JSON_MINIMAL
arr->arr.ushorts.store[offset] = (unsigned short)strtoul(cp, &ep, 0);
if (ep == cp)
return JSON_ERR_BADNUM;
else
cp = ep;
break;
#endif /* JSON_MINIMAL */
case t_time:
#ifndef JSON_MINIMAL
if (*cp != '"')
return JSON_ERR_BADSTRING;
else
++cp;
arr->arr.reals.store[offset] = iso8601_to_unix((char *)cp);
if (arr->arr.reals.store[offset] >= HUGE_VAL)
return JSON_ERR_BADNUM;
while (*cp && *cp != '"')
cp++;
if (*cp != '"')
return JSON_ERR_BADSTRING;
else
++cp;
break;
#endif /* JSON_MINIMAL */
case t_real:
#ifndef JSON_MINIMAL
arr->arr.reals.store[offset] = strtod(cp, &ep);
if (ep == cp)
return JSON_ERR_BADNUM;
else
cp = ep;
break;
#endif /* JSON_MINIMAL */
case t_boolean:
#ifndef JSON_MINIMAL
if (str_starts_with(cp, "true")) {
arr->arr.booleans.store[offset] = true;
cp += 4;
}
else if (str_starts_with(cp, "false")) {
arr->arr.booleans.store[offset] = false;
cp += 5;
}
break;
#endif /* JSON_MINIMAL */
case t_character:
case t_array:
case t_check:
case t_ignore:
json_debug_trace((1, "Invalid array subtype.\n"));
return JSON_ERR_SUBTYPE;
}
arrcount++;
if (isspace((unsigned char) *cp))
cp++;
if (*cp == ']') {
json_debug_trace((1, "End of array found.\n"));
goto breakout;
} else if (*cp == ',')
cp++;
else {
json_debug_trace((1, "Bad trailing syntax on array.\n"));
return JSON_ERR_BADSUBTRAIL;
}
}
json_debug_trace((1, "Too many elements in array.\n"));
#ifndef JSON_MINIMAL
if (end != NULL)
*end = cp;
#endif /* JSON_MINIMAL */
return JSON_ERR_SUBTOOLONG;
breakout:
if (arr->count != NULL)
*(arr->count) = arrcount;
if (end != NULL)
*end = cp;
json_debug_trace((1, "leaving json_read_array() with %d elements\n",
arrcount));
return 0;
}
inline bool isGroupRecipeStr(const std::string &rec_name)
{
return str_starts_with(rec_name, std::string("group:"));
}
static void sirf_update(void)
{
int i, j, ch, sv;
unsigned char *buf;
size_t len;
uint8_t dgps;
char tbuf[JSON_DATE_MAX+1];
buf = session.lexer.outbuffer + 4;
len = session.lexer.outbuflen - 8;
switch (buf[0]) {
case 0x02: /* Measured Navigation Data */
(void)wmove(mid2win, 1, 6); /* ECEF position */
(void)wprintw(mid2win, "%8d %8d %8d", getbes32(buf, 1),
getbes32(buf, 5), getbes32(buf, 9));
(void)wmove(mid2win, 2, 6); /* ECEF velocity */
(void)wprintw(mid2win, "%8.1f %8.1f %8.1f",
(double)getbes16(buf, 13) / 8, (double)getbes16(buf,
15) / 8,
(double)getbes16(buf, 17) / 8);
decode_ecef((double)getbes32(buf, 1), (double)getbes32(buf, 5),
(double)getbes32(buf, 9), (double)getbes16(buf, 13) / 8,
(double)getbes16(buf, 15) / 8, (double)getbes16(buf,
17) / 8);
/* line 3 */
(void)wmove(mid2win, 3, 7);
(void)wprintw(mid2win, "%-24s",
unix_to_iso8601(session.gpsdata.fix.time, tbuf, sizeof(tbuf))
);
(void)wmove(mid2win, 3, 38);
(void)wattrset(mid2win, A_UNDERLINE);
if (ppstime_enabled)
(void)wprintw(mid2win, "%02d", leapseconds);
else
(void)wprintw(mid2win, "??");
(void)wattrset(mid2win, A_NORMAL);
/* line 4 */
/* HDOP */
(void)wmove(mid2win, 4, 59);
(void)wprintw(mid2win, "%4.1f", (double)getub(buf, 20) / 5);
/* Mode 1 */
(void)wmove(mid2win, 4, 69);
(void)wprintw(mid2win, "%02x", getub(buf, 19));
/* Mode 2 */
(void)wmove(mid2win, 4, 77);
(void)wprintw(mid2win, "%02x", getub(buf, 21));
/* SVs in fix */
(void)wmove(mid2win, 4, 6);
(void)wprintw(mid2win, "%2d = ",
(int)getub(buf, 28));
/* SV list */
(void)wmove(mid2win, 4, 10);
/* coverity_submit[tainted_data] */
for (i = 0; i < (int)getub(buf, 28); i++)
(void)wprintw(mid2win, " %2d", (int)getub(buf, 29 + i));
monitor_log("MND 0x02=");
break;
case 0x04: /* Measured Tracking Data */
ch = (int)getub(buf, 7);
for (i = 0; i < ch; i++) {
int az, el, state, off;
double cn;
off = 8 + 15 * i;
(void)wmove(mid4win, i + 2, 3);
sv = (int)getub(buf, off);
az = (int)getub(buf, off + 1) * 3 / 2;
el = (int)getub(buf, off + 2) / 2;
state = (int)getbeu16(buf, off + 3);
cn = 0;
for (j = 0; j < 10; j++)
cn += (int)getub(buf, off + 5 + j);
cn /= 10;
(void)wprintw(mid4win, " %3d %3d %2d %04x %4.1f %c",
sv, az, el, state, cn, state == 0xbf ? 'T' : ' ');
}
monitor_log("MTD 0x04=");
break;
#ifdef __UNUSED__
case 0x05: /* raw track data */
for (off = 1; off < len; off += 51) {
ch = getbeu32(buf, off);
(void)wmove(mid4win, ch + 2, 19);
cn = 0;
for (j = 0; j < 10; j++)
cn += getub(buf, off + 34 + j);
printw("%5.1f", (double)cn / 10);
printw("%9d%3d%5d", getbeu32(buf, off + 8),
(int)getbeu16(buf, off + 12), (int)getbeu16(buf, off + 14));
printw("%8.5f %10.5f", (double)getbeu32(buf, off + 16) / 65536,
(double)getbeu32(buf, off + 20) / 1024);
}
monitor_log("RTD 0x05=");
break;
#endif /* __UNUSED */
case 0x06: /* firmware version */
display(mid6win, 1, 1, "%s", buf + 1);
monitor_log("FV 0x06=");
break;
case 0x07: /* Response - Clock Status Data */
display(mid7win, 1, 5, "%2d", getub(buf, 7)); /* SVs */
display(mid7win, 1, 16, "%lu", getbeu32(buf, 8)); /* Clock ppstimes */
display(mid7win, 1, 29, "%lu", getbeu32(buf, 12)); /* Clock Bias */
display(mid7win, 2, 11, "%lu", getbeu32(buf, 16)); /* Estimated Time */
monitor_log("CSD 0x07=");
break;
case 0x08: /* 50 BPS data */
ch = (int)getub(buf, 1);
sv = (int)getub(buf, 2);
display(mid4win, ch + 2, 27, "%2d", sv);
subframe_enabled = true;
monitor_log("50B 0x08=");
break;
case 0x09: /* Throughput */
display(mid9win, 1, 6, "%.3f", (double)getbeu16(buf, 1) / 186); /*SegStatMax */
display(mid9win, 1, 18, "%.3f", (double)getbeu16(buf, 3) / 186); /*SegStatLat */
display(mid9win, 1, 31, "%.3f", (double)getbeu16(buf, 5) / 186); /*SegStatTime */
display(mid9win, 1, 42, "%3d", (int)getbeu16(buf, 7)); /* Last Millisecond */
monitor_log("THR 0x09=");
break;
case 0x0b: /* Command Acknowledgement */
monitor_log("ACK 0x0b=");
break;
case 0x0c: /* Command NAcknowledgement */
monitor_log("NAK 0x0c=");
break;
case 0x0d: /* Visible List */
display(mid13win, 1, 1, "%02d = ",
getub(buf, 1));
(void)wmove(mid13win, 1, 5);
for (i = 0; i < (int)getub(buf, 1); i++)
(void)wprintw(mid13win, " %d", getub(buf, 2 + 5 * i));
monitor_log("VL 0x0d=");
break;
case 0x13:
#define YESNO(n) (((int)getub(buf, n) != 0)?'Y':'N')
display(mid19win, 1, 20, "%d", getub(buf, 5)); /* Alt. hold mode */
display(mid19win, 2, 20, "%d", getub(buf, 6)); /* Alt. hold source */
display(mid19win, 3, 20, "%dm", (int)getbeu16(buf, 7)); /* Alt. source input */
if (getub(buf, 9) != (uint8_t) '\0')
display(mid19win, 4, 20, "%dsec", getub(buf, 10)); /* Degraded timeout */
else
display(mid19win, 4, 20, "N/A ");
display(mid19win, 5, 20, "%dsec", getub(buf, 11)); /* DR timeout */
display(mid19win, 6, 20, "%c", YESNO(12)); /* Track smooth mode */
display(mid19win, 7, 20, "%c", YESNO(13)); /* Static Nav. */
display(mid19win, 8, 20, "0x%x", getub(buf, 14)); /* 3SV Least Squares */
display(mid19win, 9, 20, "0x%x", getub(buf, 19)); /* DOP Mask mode */
display(mid19win, 10, 20, "0x%x", (int)getbeu16(buf, 20)); /* Nav. Elev. mask */
display(mid19win, 11, 20, "0x%x", getub(buf, 22)); /* Nav. Power mask */
display(mid19win, 12, 20, "0x%x", getub(buf, 27)); /* DGPS Source */
display(mid19win, 13, 20, "0x%x", getub(buf, 28)); /* DGPS Mode */
display(mid19win, 14, 20, "%dsec", getub(buf, 29)); /* DGPS Timeout */
display(mid19win, 1, 42, "%c", YESNO(34)); /* LP Push-to-Fix */
display(mid19win, 2, 42, "%dms", getbeu32(buf, 35)); /* LP On Time */
display(mid19win, 3, 42, "%d", getbeu32(buf, 39)); /* LP Interval */
display(mid19win, 4, 42, "%c", YESNO(43)); /* User Tasks enabled */
display(mid19win, 5, 42, "%d", getbeu32(buf, 44)); /* User Task Interval */
display(mid19win, 6, 42, "%c", YESNO(48)); /* LP Power Cycling Enabled */
display(mid19win, 7, 42, "%d", getbeu32(buf, 49)); /* LP Max Acq Search Time */
display(mid19win, 8, 42, "%d", getbeu32(buf, 53)); /* LP Max Off Time */
display(mid19win, 9, 42, "%c", YESNO(57)); /* APM Enabled */
display(mid19win, 10, 42, "%d", (int)getbeu16(buf, 58)); /* # of fixes */
display(mid19win, 11, 42, "%d", (int)getbeu16(buf, 60)); /* Time Between fixes */
display(mid19win, 12, 42, "%d", getub(buf, 62)); /* H/V Error Max */
display(mid19win, 13, 42, "%d", getub(buf, 63)); /* Response Time Max */
display(mid19win, 14, 42, "%d", getub(buf, 64)); /* Time/Accu & Duty Cycle Priority */
#undef YESNO
monitor_log("NP 0x13=");
break;
case 0x1b:
/******************************************************************
Not actually documented in any published materials before the
1.6 version of the SiRF binary protocol manual.
Here is what Chris Kuethe got from the SiRF folks,
(plus some corrections from the GpsPaSsion forums):
Start of message
----------------
Message ID 1 byte 27
Correction Source 1 byte 0=None, 1=SBAS, 2=Serial, 3=Beacon,
4=Software
total: 2 bytes
Middle part of message varies if using beacon or other:
-------------------------------------------------------
If Beacon:
Receiver Freq Hz 4 bytes
Bit rate BPS 1 byte
Status bit map 1 byte 01=Signal Valid,
02=Auto frequency detect
04=Auto bit rate detect
Signal Magnitude 4 bytes Note: in internal units
Signal Strength dB 2 bytes derived from Signal Magnitude
SNR dB 2 bytes
total: 14 bytes
If Not Beacon:
Correction Age[12] 1 byte x 12 Age in seconds in same order as follows
Reserved 2 bytes
total: 14 bytes
End of Message
--------------
Repeated 12 times (pad with 0 if less than 12 SV corrections):
SVID 1 byte
Correction (cm) 2 bytes (signed short)
total 3 x 12 = 36 bytes
******************************************************************/
dgps = getub(buf, 1);
display(mid27win, 1, 1, "%8s = ",
(CHECK_RANGE(dgpsvec, dgps) ? dgpsvec[dgps] : "???"));
(void)wmove(mid27win, 1, 11);
for (ch = 0; ch < SIRF_CHANNELS; ch++)
if (getub(buf, 16 + 3 * ch) != '\0')
(void)wprintw(mid27win, " %d", getub(buf, 16 + 3 * ch));
monitor_log("DST 0x1b=");
break;
case 0x1c: /* NL Measurement Data */
case 0x1d: /* NL DGPS Data */
case 0x1e: /* NL SV State Data */
case 0x1f: /* NL Initialized Data */
subframe_enabled = true;
monitor_log("NL 0x%02x=", buf[0]);
break;
case 0x29: /* Geodetic Navigation Data */
monitor_log("GND 0x29=");
break;
case 0x32: /* SBAS Parameters */
monitor_log("SBP 0x32=");
break;
case 0x34: /* PPS Time */
ppstime_enabled = true;
leapseconds = (int)getbeu16(buf, 8);
monitor_log("PPS 0x34=");
break;
case 0xff: /* Development Data */
while (len > 0 && buf[len - 1] == '\n')
len--;
while (len > 0 && buf[len - 1] == ' ')
len--;
buf[len] = '\0';
j = 1;
for (i = 0; verbpat[i] != NULL; i++)
if (str_starts_with((char *)(buf + 1), verbpat[i])) {
j = 0;
break;
}
if (j != 0)
monitor_log("%s\n", buf + 1);
monitor_log("DD 0xff=");
break;
default:
monitor_log("UNK 0x%02x=", buf[0]);
break;
}
#ifdef CONTROLSEND_ENABLE
/* elicit navigation parameters */
if (dispmode && (time(NULL) % 10 == 0)) {
(void)monitor_control_send((unsigned char *)"\x98\x00", 2);
}
#endif /* CONTROLSEND_ENABLE */
/* clear the 50bps data field every 6 seconds */
if (subframe_enabled && (time(NULL) % 6 == 0)) {
for (ch = 0; ch < SIRF_CHANNELS; ch++)
display(mid4win, ch + 2, 27, " ");
}
if (dispmode) {
(void)touchwin(mid19win);
(void)wnoutrefresh(mid19win);
}
#ifdef PPS_ENABLE
pps_update(mid7win, 2, 32);
#endif /* PPS_ENABLE */
}
