section_type* regini_file::get_section(string section_name)
{
section_name = string_tolower(section_name);
for (size_t i = 0; i < section.size(); i++)
{
string sname = string_tolower(section[i].name);
if (sname.compare(section_name) == 0)
return §ion[i];
}
return nullptr;
}
int v4l2_query_ctrl(unsigned int addr_begin, unsigned int addr_end) {
struct v4l2_queryctrl queryctrl;
std::string key;
for (queryctrl.id = addr_begin;
queryctrl.id < addr_end;
queryctrl.id++) {
if (ioctl(video_fd, VIDIOC_QUERYCTRL, &queryctrl) == -1) {
if (errno == EINVAL)
continue;
else
return v4l2_error("Could not query control");
}
fprintf(stdout, "queryctrl: \"%s\" 0x%x\n",
queryctrl.name, queryctrl.id);
switch (queryctrl.type) {
case V4L2_CTRL_TYPE_MENU:
v4l2_query_menu(queryctrl);
// fall throught
case V4L2_CTRL_TYPE_INTEGER:
case V4L2_CTRL_TYPE_BOOLEAN:
case V4L2_CTRL_TYPE_BUTTON:
key = (char *)queryctrl.name;
string_tolower(key);
ctrlMap[key] = queryctrl;
break;
default:
break;
}
}
}
//-------------------------------------------------------------------------
// Main
// Handle the Request, Handle (Send) Response), End the Connection
//-------------------------------------------------------------------------
void CWebserverConnection::HandleConnection() {
gettimeofday(&tv_connection_start, &tz_connection_start);
// get the request
if (Request.HandleRequest()) {
// determine time from Connection creation until now
gettimeofday(&tv_connection_Response_start,
&tz_connection_Response_start);
enlapsed_request = ((tv_connection_Response_start.tv_sec
- tv_connection_start.tv_sec) * 1000000
+ (tv_connection_Response_start.tv_usec
- tv_connection_start.tv_usec));
// Keep-Alive checking
#ifdef Y_CONFIG_FEATURE_KEEP_ALIVE
if(string_tolower(Request.HeaderList["Connection"]) == "close"
|| (httprotocol != "HTTP/1.1" && string_tolower(Request.HeaderList["Connection"]) != "keep-alive")
|| !Webserver->CheckKeepAliveAllowedByIP(sock->get_client_ip()))
keep_alive = false;
#else
keep_alive = false;
#endif
// Send a response
Response.SendResponse();
// determine time for SendResponse
gettimeofday(&tv_connection_Response_end, &tz_connection_Response_end);
enlapsed_response = ((tv_connection_Response_end.tv_sec
- tv_connection_Response_start.tv_sec) * 1000000
+ (tv_connection_Response_end.tv_usec
- tv_connection_Response_start.tv_usec));
// print production times
log_level_printf(1, "enlapsed time request:%ld response:%ld url:%s\n",
enlapsed_request, enlapsed_response,
(Request.UrlData["fullurl"]).c_str());
} else {
RequestCanceled = true;
keep_alive = false; // close this connection socket
// dperror("Error while parsing request\n");
log_level_printf(1, "request canceled: %s\n", strerror(errno));
}
EndConnection();
}
int main()
{
char *string = read_line();
string = string_tolower(string);
char *sub = read_line();
printf("%d\n", countSubstringOccurances(string,sub));
return 0;
}
entry_type* regini_file::get_entry(string section_name, string key_name)
{
section_type* sec = get_section(section_name);
if (sec != nullptr)
{
key_name = string_tolower(key_name);
for (size_t i = 0; i < sec->entry.size(); i++)
{
string ekeyname = string_tolower(sec->entry[i].key);
if (ekeyname.compare(key_name) == 0)
return &sec->entry[i];
}
}
return nullptr;
}
//-----------------------------------------------------------------------------
// Send File: Determine MIME-Type fro File-Extention
//-----------------------------------------------------------------------------
std::string CWebserverResponse::GetContentType(std::string ext)
{
std::string ctype = "text/plain";
ext = string_tolower(ext);
for (unsigned int i = 0;i < (sizeof(MimeFileExtensions)/sizeof(MimeFileExtensions[0])); i++)
if (MimeFileExtensions[i].fileext == ext)
{
ctype = MimeFileExtensions[i].mime;
break;
}
return ctype;
}
int main(void){
char asd[] = "ajeje";
char foo[] = "FOOBAR";
printf("%d\n", is_vowel('A'));
printf("%d\n", is_vowel('b'));
printf("%d\n", char_to_digit('5'));
printf("%s\n", string_toupper(asd));
printf("%s\n", string_tolower(foo));
return 0;
}
TEST(String, Case)
{
char *str;
str = strdup ("ABC");
string_tolower (str);
STRCMP_EQUAL("abc", str);
string_toupper (str);
STRCMP_EQUAL("ABC", str);
free (str);
}
//-----------------------------------------------------------------------------
// URL Function Dispatching
//-----------------------------------------------------------------------------
void CyParser::Execute(CyhookHandler *hh) {
int index = -1;
std::string filename = hh->UrlData["filename"];
log_level_printf(4, "yParser.Execute filename%s\n", filename.c_str());
filename = string_tolower(filename);
// debugging informations
if (CLogging::getInstance()->getDebug()) {
dprintf("Execute CGI : %s\n", filename.c_str());
for (CStringList::iterator it = hh->ParamList.begin(); it
!= hh->ParamList.end(); it++)
dprintf(" Parameter %s : %s\n", it->first.c_str(),
it->second.c_str());
}
// get function index
for (unsigned int i = 0; i < (sizeof(yCgiCallList)
/ sizeof(yCgiCallList[0])); i++)
if (filename == yCgiCallList[i].func_name) {
index = i;
break;
}
if (index == -1) // function not found
{
hh->SetError(HTTP_NOT_IMPLEMENTED, HANDLED_NOT_IMPLEMENTED);
return;
}
// send header
if (std::string(yCgiCallList[index].mime_type) == "") // set by self
;
else if (std::string(yCgiCallList[index].mime_type) == "+xml") // Parameter xml?
if (hh->ParamList["xml"] != "")
hh->SetHeader(HTTP_OK, "text/xml");
else
hh->SetHeader(HTTP_OK, "text/plain");
else
hh->SetHeader(HTTP_OK, yCgiCallList[index].mime_type);
// response
hh->status = HANDLED_READY;
if (hh->Method == M_HEAD) // HEAD or function call
return;
else {
(this->*yCgiCallList[index].pfunc)(hh);
return;
}
}
int v4l2_get_ctrl(const char *name, int *value) {
std::string key(name);
string_tolower(key);
std::map<std::string, struct v4l2_queryctrl>::iterator ictrl
= ctrlMap.find(name);
if (ictrl == ctrlMap.end()) {
fprintf(stderr, "Unknown control");
return -1;
}
struct v4l2_control ctrl;
ctrl.id = (ictrl->second).id;
int ret=xioctl(video_fd, VIDIOC_G_CTRL, &ctrl);
*value = ctrl.value;
return ret;
}
void
plugin_config_set_desc (const char *plugin_name, const char *option_name,
const char *description)
{
int length;
char *option_full_name;
length = strlen (plugin_name) + 1 + strlen (option_name) + 1;
option_full_name = malloc (length);
if (option_full_name)
{
snprintf (option_full_name, length, "%s.%s",
plugin_name, option_name);
string_tolower (option_full_name);
plugin_config_set_desc_internal (option_full_name, description);
free (option_full_name);
}
}
//===========================================================================
bool cLoadMeshFromFile(cMesh* a_mesh, const string& a_fileName)
{
// verify mesh object
if (a_mesh == NULL) { return (false); }
// retrieve filename
const char* filename = a_fileName.c_str();
char* extension = find_extension(filename);
// We need a file extension to figure out file type
if (extension == 0)
{
return false;
}
char lower_extension[1024];
string_tolower(lower_extension,extension);
// return value
bool result = false;
// Load an .obj file
if (strcmp(lower_extension,"obj")==0)
{
result = cLoadFileOBJ(a_mesh, a_fileName);
}
// Load a .3ds file
else if (strcmp(lower_extension,"3ds")==0)
{
result = cLoadFile3DS(a_mesh, a_fileName);
}
// if file has loaded, set the super parent to all child nodes.
// the root (current object a_mesh) becomes the super parent of itself.
if (result)
{
a_mesh->setSuperParent(a_mesh, true);
}
// return result
return(result);
}
int
plugin_config_set (const char *plugin_name, const char *option_name,
const char *value)
{
int length, rc;
char *option_full_name;
rc = WEECHAT_CONFIG_OPTION_SET_ERROR;
length = strlen (plugin_name) + 1 + strlen (option_name) + 1;
option_full_name = malloc (length);
if (option_full_name)
{
snprintf (option_full_name, length, "%s.%s",
plugin_name, option_name);
string_tolower (option_full_name);
rc = plugin_config_set_internal (option_full_name, value);
free (option_full_name);
}
return rc;
}
//===========================================================================
bool cImageLoader::loadFromFile(const char* filename)
{
// Sometimes we'll make a one-level recursive call into this
// function; this is an extra safety check to avoid extra
// recursion...
static int recursive_call = 0;
// cleanup previous image
cleanup();
strncpy(m_filename,filename,CHAI_SIZE_PATH);
m_filename[CHAI_SIZE_PATH-1] = '\0';
char* extension = find_extension(filename);
// We need a file extension to figure out file type
if (extension == 0)
{
cleanup();
return (false);
}
char lower_extension[1024];
string_tolower(lower_extension,extension);
//--------------------------------------------------------------------
// Load a .tga image
//--------------------------------------------------------------------
if (strcmp(lower_extension,"tga")==0)
{
cFileLoaderTGA targa_image;
// Load the targa file from disk
bool result = targa_image.LoadFromFile(m_filename);
if (!result)
{
cleanup();
// Try again using the windows native loader...
result = loadFromFileOLE(filename);
return (result);
}
m_width = targa_image.GetImageWidth();
m_height = targa_image.GetImageHeight();
// Find the correct openGL format for this .tga file
GLenum format = (targa_image.GetImageType());
if (format == itRGB)
{
m_bits_per_pixel = 24;
m_format = GL_RGB;
}
else if (format == itRGBA)
{
m_bits_per_pixel = 32;
m_format = GL_RGBA;
}
else
{
// Unrecognized format...
cleanup();
// Try again using the windows native loader...
bool result = loadFromFileOLE(filename);
return (result);
}
m_data = new unsigned char[m_width*m_height*(m_bits_per_pixel/8)];
// Copy tga data into our internal data record
memcpy(m_data,targa_image.GetPixels(),(m_bits_per_pixel/8)*m_width*m_height);
}
//--------------------------------------------------------------------
// Load a .bmp image
//--------------------------------------------------------------------
else if (strcmp(lower_extension,"bmp")==0)
{
cFileLoaderBMP bmp_image;
bool result = bmp_image.loadBMP(m_filename);
if (!result)
{
cleanup();
// Try again using the windows native loader...
result = loadFromFileOLE(filename);
return (result);
}
m_width = bmp_image.getWidth();
m_height = bmp_image.getHeight();
m_bits_per_pixel = 24;
m_data = new unsigned char[m_width*m_height*(m_bits_per_pixel/8)];
// Copy bmp data into our internal data record
memcpy(m_data,bmp_image.pBitmap(),(m_bits_per_pixel/8)*m_width*m_height);
}
#if defined(_WIN32)
//--------------------------------------------------------------------
// Unrecognized file format - use win32 loader
//--------------------------------------------------------------------
else
{
bool result = loadFromFileOLE(filename);
return (result);
}
#else
//--------------------------------------------------------------------
// Unrecognized file format an win32 not available - try again as a .bmp
//--------------------------------------------------------------------
else if (recursive_call == 0)
int ArdbServer::Set(ArdbConnContext& ctx, RedisCommandFrame& cmd)
{
const std::string& key = cmd.GetArguments()[0];
const std::string& value = cmd.GetArguments()[1];
int ret = 0;
if (cmd.GetArguments().size() == 2)
{
ret = m_db->Set(ctx.currentDB, key, value);
}
else
{
uint32 i = 0;
uint64 px = 0, ex = 0;
for (i = 2; i < cmd.GetArguments().size(); i++)
{
std::string tmp = string_tolower(cmd.GetArguments()[i]);
if (tmp == "ex" || tmp == "px")
{
int64 iv;
if (!raw_toint64(cmd.GetArguments()[i + 1].c_str(), cmd.GetArguments()[i + 1].size(), iv) || iv < 0)
{
fill_error_reply(ctx.reply, "value is not an integer or out of range");
return 0;
}
if (tmp == "px")
{
px = iv;
}
else
{
ex = iv;
}
i++;
}
else
{
break;
}
}
bool hasnx = false, hasxx = false;
bool syntaxerror = false;
if (i < cmd.GetArguments().size() - 1)
{
syntaxerror = true;
}
if (i == cmd.GetArguments().size() - 1)
{
std::string cmp = string_tolower(cmd.GetArguments()[i]);
if (cmp != "nx" && cmp != "xx")
{
syntaxerror = true;
}
else
{
hasnx = cmp == "nx";
hasxx = cmp == "xx";
}
}
if (syntaxerror)
{
fill_error_reply(ctx.reply, "syntax error");
return 0;
}
int nxx = 0;
if (hasnx)
{
nxx = -1;
}
if (hasxx)
{
nxx = 1;
}
ret = m_db->Set(ctx.currentDB, key, value, ex, px, nxx);
}
if (0 == ret)
{
fill_status_reply(ctx.reply, "OK");
}
else
{
switch (ret)
{
case ERR_INVALID_TYPE:
{
fill_error_reply(ctx.reply, "invalid type");
break;
}
case ERR_KEY_EXIST:
case ERR_NOT_EXIST:
{
ctx.reply.type = REDIS_REPLY_NIL;
break;
}
default:
{
fill_error_reply(ctx.reply, "set failed");
break;
}
}
}
return 0;
}
int main(int argc, char *argv[]) {
char *host = CATALOG_HOST;
int port = CATALOG_PORT;
static struct option long_options[] = {{"catalog", required_argument, 0, 'c'},
{0,0,0,0}};
signed int c;
while ((c = getopt_long(argc, argv, "c:", long_options, NULL)) > -1) {
switch (c) {
case 'c':
host = optarg;
break;
default:
show_help(argv[0]);
return EXIT_FAILURE;
}
}
struct datagram *d;
d = datagram_create(DATAGRAM_PORT_ANY);
if (!d) {
fatal("could not create datagram port!");
}
buffer_t B;
const char *text;
size_t text_size;
buffer_init(&B);
buffer_abortonfailure(&B, 1);
struct utsname name;
int cpus;
int uptime;
double load[3];
UINT64_T memory_total, memory_avail;
char owner[USERNAME_MAX];
uname(&name);
string_tolower(name.sysname);
string_tolower(name.machine);
string_tolower(name.release);
load_average_get(load);
cpus = load_average_get_cpus();
memory_info_get(&memory_avail, &memory_total);
uptime = uptime_get();
username_get(owner);
buffer_printf(&B, "type %s\nversion %d.%d.%s\ncpu %s\nopsys %s\nopsysversion %s\nload1 %0.02lf\nload5 %0.02lf\nload15 %0.02lf\nmemory_total %llu\nmemory_avail %llu\ncpus %d\nuptime %d\nowner %s\n",
DEFAULT_TYPE,
CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO,
name.machine,
name.sysname,
name.release,
load[0],
load[1],
load[2],
(unsigned long long) memory_total,
(unsigned long long) memory_avail,
cpus,
uptime,
owner
);
int i;
for (i = optind; i < argc; i++) {
char *name;
char *value;
name = argv[i];
value = strchr(name, '=');
if (!value) {
fatal("invalid name/value pair = %s", name);
} else {
*value++ = 0;
}
buffer_printf(&B, "%s %s\n", name, value);
}
text = buffer_tostring(&B, &text_size);
char address[DATAGRAM_ADDRESS_MAX];
if (domain_name_cache_lookup(host, address)) {
datagram_send(d, text, text_size, address, port);
} else {
fatal("unable to lookup address of host: %s", host);
}
buffer_free(&B);
datagram_delete(d);
return EXIT_SUCCESS;
}
/**
* Parse the metaserver certificate information.
*
* @param server
* Metaserver entry.
* @return
* True on success, false on failure.
*/
static bool
parse_metaserver_cert (server_struct *server)
{
HARD_ASSERT(server != NULL);
if (server->cert == NULL || server->cert_sig == NULL) {
/* No certificate. */
return true;
}
/* Generate a SHA512 hash of the certificate's contents. */
unsigned char cert_digest[SHA512_DIGEST_LENGTH];
if (SHA512((unsigned char *) server->cert,
strlen(server->cert),
cert_digest) == NULL) {
LOG(ERROR, "SHA512() failed: %s",
ERR_error_string(ERR_get_error(), NULL));
return false;
}
char cert_hash[SHA512_DIGEST_LENGTH * 2 + 1];
SOFT_ASSERT_RC(string_tohex(VS(cert_digest),
VS(cert_hash),
false) == sizeof(cert_hash) - 1,
false,
"string_tohex failed");
string_tolower(cert_hash);
/* Verify the signature. */
if (!curl_verify(CURL_PKEY_TRUST_ULTIMATE,
cert_hash,
strlen(cert_hash),
server->cert_sig,
server->cert_sig_len)) {
LOG(ERROR, "Failed to verify signature");
return false;
}
server_cert_info_t *info = ecalloc(1, sizeof(*info));
char buf[MAX_BUF];
size_t pos = 0;
bool in_info = false;
while (string_get_word(server->cert, &pos, '\n', VS(buf), 0)) {
char *cp = buf;
string_skip_whitespace(cp);
string_strip_newline(cp);
if (*cp == '\0') {
continue;
}
if (strcmp(cp, cert_begin_str) == 0) {
in_info = true;
continue;
} else if (!in_info) {
continue;
} else if (strcmp(cp, cert_end_str) == 0) {
break;
}
char *cps[2];
if (string_split(cp, cps, arraysize(cps), ':') != arraysize(cps)) {
LOG(ERROR, "Parsing error");
continue;
}
string_tolower(cps[0]);
string_skip_whitespace(cps[1]);
const char *key = cps[0];
const char *value = cps[1];
char **content = NULL;
if (strcmp(key, "name") == 0) {
content = &info->name;
} else if (strcmp(key, "hostname") == 0) {
content = &info->hostname;
} else if (strcmp(key, "ipv4 address") == 0) {
content = &info->ipv4_address;
} else if (strcmp(key, "ipv6 address") == 0) {
content = &info->ipv6_address;
} else if (strcmp(key, "public key") == 0) {
content = &info->pubkey;
} else if (strcmp(key, "port") == 0) {
info->port = atoi(value);
} else if (strcmp(key, "crypto port") == 0) {
info->port_crypto = atoi(value);
} else {
LOG(DEVEL, "Unrecognized key: %s", key);
continue;
}
if (content != NULL) {
StringBuffer *sb = stringbuffer_new();
if (*content != NULL) {
stringbuffer_append_string(sb, *content);
stringbuffer_append_char(sb, '\n');
efree(*content);
}
stringbuffer_append_string(sb, value);
*content = stringbuffer_finish(sb);
}
}
/* Ensure we got the data we need. */
if (info->name == NULL ||
info->hostname == NULL ||
info->pubkey == NULL ||
info->port_crypto <= 0 ||
(info->ipv4_address == NULL) != (info->ipv6_address == NULL)) {
LOG(ERROR,
"Certificate is missing required data.");
goto error;
}
/* Ensure certificate attributes match the advertised ones. */
if (strcmp(info->hostname, server->hostname) != 0) {
LOG(ERROR,
"Certificate hostname does not match advertised hostname.");
goto error;
}
if (strcmp(info->name, server->name) != 0) {
LOG(ERROR,
"Certificate name does not match advertised name.");
goto error;
}
if (info->port != server->port) {
LOG(ERROR,
"Certificate port does not match advertised port.");
goto error;
}
if (info->port_crypto != server->port_crypto) {
LOG(ERROR,
"Certificate crypto port does not match advertised crypto port.");
goto error;
}
server->cert_info = info;
return true;
error:
metaserver_cert_free(info);
return false;
}
//[[Rcpp::export]]
std::string string_tolower_single(std::string str){
return string_tolower(str);
}
int main(int argc, char *argv[]) {
char *host = CATALOG_HOST;
int port = CATALOG_PORT;
static const struct option long_options[] = {
{"catalog", required_argument, 0, 'c'},
{0,0,0,0}
};
signed int c;
while ((c = getopt_long(argc, argv, "c:", long_options, NULL)) > -1) {
switch (c) {
case 'c':
host = optarg;
break;
default:
show_help(argv[0]);
return EXIT_FAILURE;
}
}
struct datagram *d;
d = datagram_create(DATAGRAM_PORT_ANY);
if (!d) {
fatal("could not create datagram port!");
}
struct utsname name;
int cpus;
int uptime;
double load[3];
UINT64_T memory_total, memory_avail;
char owner[USERNAME_MAX];
uname(&name);
string_tolower(name.sysname);
string_tolower(name.machine);
string_tolower(name.release);
load_average_get(load);
cpus = load_average_get_cpus();
host_memory_info_get(&memory_avail, &memory_total);
uptime = uptime_get();
username_get(owner);
struct jx *j = jx_object(0);
jx_insert_string(j,"type","node");
jx_insert(j,jx_string("version"),jx_format("%d.%d.%d",CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO));
jx_insert_string(j,"cpu",name.machine);
jx_insert_string(j,"opsys",name.sysname);
jx_insert_string(j,"opsysversion",name.release);
jx_insert_double(j,"load1",load[0]);
jx_insert_double(j,"load5",load[1]);
jx_insert_double(j,"load15",load[2]);
jx_insert_integer(j,"memory_total",memory_total);
jx_insert_integer(j,"memory_avail",memory_avail);
jx_insert_integer(j,"cpus",cpus);
jx_insert_integer(j,"uptime,",uptime);
jx_insert_string(j,"owner",owner);
int i;
for (i = optind; i < argc; i++) {
char *name;
char *value;
name = argv[i];
value = strchr(name, '=');
if (!value) {
fatal("invalid name/value pair = %s", name);
} else {
*value++ = 0;
}
jx_insert_string(j,name,value);
}
char *text = jx_print_string(j);
char address[DATAGRAM_ADDRESS_MAX];
if (domain_name_cache_lookup(host, address)) {
datagram_send(d, text, strlen(text), address, port);
} else {
fatal("unable to lookup address of host: %s", host);
}
jx_delete(j);
datagram_delete(d);
return EXIT_SUCCESS;
}
static jdns_dnsparams_t *dnsparams_get_unixfiles()
{
FILE *f;
jdns_dnsparams_t *params;
params = jdns_dnsparams_new();
f = jdns_fopen("/etc/resolv.conf", "r");
if(!f)
return params;
while(1)
{
int n;
jdns_string_t *line, *simp;
jdns_stringlist_t *parts;
line = file_nextline(f);
if(!line)
break;
// truncate at comment
n = string_indexOf(line, '#', 0);
if(n != -1)
{
line->size = n;
line->data[n] = 0;
}
simp = string_simplify(line);
jdns_string_delete(line);
parts = string_split(simp, ' ');
jdns_string_delete(simp);
if(parts->count < 2)
{
jdns_stringlist_delete(parts);
continue;
}
simp = string_tolower(parts->item[0]);
if(strcmp((char *)simp->data, "nameserver") == 0)
{
jdns_address_t *addr = jdns_address_new();
jdns_address_set_cstr(addr, (const char *)parts->item[1]->data);
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
else if(strcmp((char *)simp->data, "search") == 0)
{
for(n = 1; n < parts->count; ++n)
{
jdns_dnsparams_append_domain(params, parts->item[n]);
}
}
else if(strcmp((char *)simp->data, "domain") == 0)
{
jdns_dnsparams_append_domain(params, parts->item[1]);
}
jdns_string_delete(simp);
jdns_stringlist_delete(parts);
}
fclose(f);
return params;
}
//[[Rcpp::export]]
std::vector < std::string > string_tolower_vector(std::vector < std::string > str){
return string_tolower(str);
}
static jdns_dnsparams_t *dnsparams_get_winreg()
{
int n;
jdns_dnsparams_t *params;
HKEY key;
int ret;
char sep;
jdns_string_t *str_domain, *str_nameserver, *str_searchlist;
jdns_stringlist_t *list_nameserver, *list_searchlist;
sep = ' ';
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
"System\\CurrentControlSet\\Services\\Tcpip\\Parameters",
0, KEY_READ, &key);
if(ret != ERROR_SUCCESS)
{
sep = ',';
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
"System\\CurrentControlSet\\Services\\VxD\\MSTCP",
0, KEY_READ, &key);
if(ret != ERROR_SUCCESS)
return 0;
}
str_domain = reg_readString(key, "DhcpDomain");
if(!str_domain)
str_domain = reg_readString(key, "Domain");
str_nameserver = reg_readString(key, "DhcpNameServer");
if(!str_nameserver)
str_nameserver = reg_readString(key, "NameServer");
str_searchlist = reg_readString(key, "SearchList");
RegCloseKey(key);
list_nameserver = 0;
if(str_nameserver)
{
list_nameserver = string_split(str_nameserver, sep);
jdns_string_delete(str_nameserver);
}
list_searchlist = 0;
if(str_searchlist)
{
// lowercase the string
jdns_string_t *p = string_tolower(str_searchlist);
jdns_string_delete(str_searchlist);
str_searchlist = p;
list_searchlist = string_split(str_searchlist, sep);
jdns_string_delete(str_searchlist);
}
params = jdns_dnsparams_new();
if(list_nameserver)
{
// qt seems to do a strange thing here by running each name
// server address through the q3dns setLabel function, and
// then pulls the result as a list of addresses. i have
// no idea why they do this, or how one IP address would
// turn into anything else, let alone several addresses.
// so, uh, we're not going to do that.
for(n = 0; n < list_nameserver->count; ++n)
{
jdns_address_t *addr = jdns_address_new();
if(jdns_address_set_cstr(addr, (char *)list_nameserver->item[n]->data))
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
jdns_stringlist_delete(list_nameserver);
}
if(str_domain)
{
if(str_domain->size > 0)
jdns_dnsparams_append_domain(params, str_domain);
jdns_string_delete(str_domain);
}
if(list_searchlist)
{
for(n = 0; n < list_searchlist->count; ++n)
{
if(list_searchlist->item[n]->size > 0)
jdns_dnsparams_append_domain(params, list_searchlist->item[n]);
}
jdns_stringlist_delete(list_searchlist);
}
return params;
}
int main(int argc, char * argv[])
{
char *base_type, *prefix, *l_prefix;
char filename[260];
FILE *file;
int i;
if (argc < 3)
{
fprintf(stderr, "syntax: gen_x_list <type> <prefix> [<include>...]\n");
return -1;
}
base_type = argv[1];
prefix = argv[2];
l_prefix = malloc(strlen(prefix) + 1);
strcpy(l_prefix, prefix);
string_tolower(l_prefix);
// Generate the .h file
sprintf(filename, "%s_list.h", l_prefix);
file = fopen(filename, "w");
if (!file)
{
fprintf(stderr, "Error: failed to open '%s'\n", filename);
return -1;
}
fprintf(file, "/* Constructed by gen_x_prop $rev\n");
fprintf(file, " */\n");
fprintf(file, "#ifndef %s_list_included\n", l_prefix);
fprintf(file, "#define %s_list_included\n", l_prefix);
for (i = 3; i < argc; i++)
fprintf(file, "#include \"%s\"\n", argv[i]);
fprintf(file, "#define _X_LIST_TYPE_ %s_LIST\n", prefix);
fprintf(file, "#define _X_LIST_TAG_ %s_LIST\n", prefix);
fprintf(file, "#define _X_BASE_TYPE_ %s\n", base_type);
fprintf(file, "#define _X_RCS_ID_ %s_list_rcs_id\n", l_prefix);
fprintf(file, "#define _X_PUSH_ %s_LIST_Push\n", prefix);
fprintf(file, "#define _X_DELETE_ %s_LIST_Delete\n", prefix);
fprintf(file, "#define _X_DELETE_IF_ %s_LIST_Delete_If\n", prefix);
fprintf(file, "#define %s_LIST_first(x) ((x)->first)\n", prefix);
fprintf(file, "#define %s_LIST_rest(x) ((x)->rest)\n", prefix);
fprintf(file, "#define _X_LIST_LOCAL_BASE_TYPE_ %s_LIST_LOCAL_BASE_TYPE_\n", prefix);
fprintf(file, "#include \"x_list.h\"\n");
fprintf(file, "#undef _X_LIST_TYPE_\n");
fprintf(file, "#undef _X_LIST_TAG_\n");
fprintf(file, "#undef _X_BASE_TYPE_\n");
fprintf(file, "#undef _X_RCS_ID_\n");
fprintf(file, "#undef _X_PUSH_\n");
fprintf(file, "#undef _X_DELETE_\n");
fprintf(file, "#undef _X_DELETE_IF_\n");
fprintf(file, "#undef _X_LIST_LOCAL_BASE_TYPE_\n");
fprintf(file, "#endif\n");
fclose(file);
// Generate the .cxx file
sprintf(filename, "%s_list.cxx", l_prefix);
file = fopen(filename, "w");
if (!file)
{
fprintf(stderr, "Error: failed to open '%s'\n", filename);
return -1;
}
fprintf(file, "/* Constructed by gen_x_prop $rev\n");
fprintf(file, " */\n");
for (i = 3; i < argc; i++)
fprintf(file, "#include \"%s\"\n", argv[i]);
fprintf(file, "#define _X_LIST_TYPE_ %s_LIST\n", prefix);
fprintf(file, "#define _X_BASE_TYPE_ %s\n", base_type);
fprintf(file, "#define _X_RCS_ID_ %s_list_rcs_id\n", l_prefix);
fprintf(file, "#define _X_PUSH_ %s_LIST_Push\n", prefix);
fprintf(file, "#define _X_DELETE_ %s_LIST_Delete\n", prefix);
fprintf(file, "#define _X_DELETE_IF_ %s_LIST_Delete_If\n", prefix);
fprintf(file, "#define _X_LIST_LOCAL_BASE_TYPE_ %s_LIST_LOCAL_BASE_TYPE_\n", prefix);
fprintf(file, "#include \"x_list.c\"\n");
fclose(file);
return 0;
}
static jdns_dnsparams_t *dnsparams_get_unixsys()
{
int n;
jdns_dnsparams_t *params;
#ifdef JDNS_MODERN_RES_API
struct __res_state res;
memset(&res, 0, sizeof(struct __res_state));
n = res_ninit(&res);
#define RESVAR res
#else
n = my_res_init();
#define RESVAR _res
#endif
params = jdns_dnsparams_new();
// error initializing?
if(n == -1)
return params;
#ifdef USE_INDEP_EXT
for(n = 0; n < MAXNS && n < RESVAR.nscount; ++n)
{
struct sockaddr_in *sa = (struct sockaddr_in*)&(_res_ext.nsaddr_list[n]);
jdns_address_t *addr = jdns_address_new();
if (sa->sin_family = AF_INET6) {
struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa;
jdns_address_set_ipv6(addr, sa6->sin6_addr.s6_addr);
} else {
jdns_address_set_ipv4(addr, ntohl(sa->sin_addr.s_addr));
}
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
#else
// nameservers - ipv6
#ifdef __GLIBC__
for(n = 0; n < MAXNS; ++n)
#else
for(n = 0; n < MAXNS && n < RESVAR._u._ext.nscount; ++n)
#endif
{
jdns_address_t *addr;
struct sockaddr_in6 *sa6;
#ifdef USE_EXTEXT
// seems _ext.ext can be null in some cases...
if(RESVAR._u._ext.ext == NULL)
break;
sa6 = ((struct sockaddr_in6 *)RESVAR._u._ext.ext) + n;
#else
sa6 = RESVAR._u._ext.nsaddrs[n];
#endif
if(sa6 == NULL)
continue;
addr = jdns_address_new();
jdns_address_set_ipv6(addr, sa6->sin6_addr.s6_addr);
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
// nameservers - ipv4
#ifdef __GLIBC__
int ns4count = RESVAR.nscount - RESVAR._u._ext.nscount6;
for(n = 0; n < MAXNS && n < ns4count; ++n)
#else
for(n = 0; n < MAXNS && n < RESVAR.nscount; ++n)
#endif
{
jdns_address_t *addr = jdns_address_new();
jdns_address_set_ipv4(addr, ntohl(RESVAR.nsaddr_list[n].sin_addr.s_addr));
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
#endif
// domain name
if(strlen(RESVAR.defdname) > 0)
{
jdns_string_t *str;
jdns_string_t *p;
str = jdns_string_new();
jdns_string_set_cstr(str, RESVAR.defdname);
p = string_tolower(str);
jdns_string_delete(str);
str = p;
jdns_dnsparams_append_domain(params, str);
jdns_string_delete(str);
}
// search list
#ifdef MAXDFLSRCH
for(n = 0; n < MAXDFLSRCH && RESVAR.dnsrch[n]; ++n)
{
if(strlen(RESVAR.dnsrch[n]) > 0)
{
jdns_string_t *str;
jdns_string_t *p;
str = jdns_string_new();
jdns_string_set_cstr(str, RESVAR.dnsrch[n]);
p = string_tolower(str);
jdns_string_delete(str);
str = p;
// don't add dups
if(!dnsparams_have_domain(params, str))
jdns_dnsparams_append_domain(params, str);
jdns_string_delete(str);
}
}
#endif
return params;
}
static jdns_dnsparams_t *dnsparams_get_unixsys()
{
int n;
jdns_dnsparams_t *params;
#ifdef JDNS_MODERN_RES_API
struct __res_state res;
memset(&res, 0, sizeof(struct __res_state));
n = res_ninit(&res);
#define RESVAR res
#else
n = my_res_init();
#define RESVAR _res
#endif
params = jdns_dnsparams_new();
// error initializing?
if(n == -1)
return params;
// nameservers - ipv6
for(n = 0; n < MAXNS && n < RESVAR._u._ext.nscount; ++n)
{
jdns_address_t *addr;
struct sockaddr_in6 *sa6;
#ifdef USE_EXTEXT
sa6 = ((struct sockaddr_in6 *)RESVAR._u._ext.ext) + n;
#else
sa6 = RESVAR._u._ext.nsaddrs[n];
#endif
if(sa6 == NULL)
continue;
addr = jdns_address_new();
jdns_address_set_ipv6(addr, sa6->sin6_addr.s6_addr);
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
// nameservers - ipv4
for(n = 0; n < MAXNS && n < RESVAR.nscount; ++n)
{
jdns_address_t *addr = jdns_address_new();
jdns_address_set_ipv4(addr, ntohl(RESVAR.nsaddr_list[n].sin_addr.s_addr));
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
// domain name
if(strlen(RESVAR.defdname) > 0)
{
jdns_string_t *str;
jdns_string_t *p;
str = jdns_string_new();
jdns_string_set_cstr(str, RESVAR.defdname);
p = string_tolower(str);
jdns_string_delete(str);
str = p;
jdns_dnsparams_append_domain(params, str);
jdns_string_delete(str);
}
// search list
#ifdef MAXDFLSRCH
for(n = 0; n < MAXDFLSRCH && RESVAR.dnsrch[n]; ++n)
{
if(strlen(RESVAR.dnsrch[n]) > 0)
{
jdns_string_t *str;
jdns_string_t *p;
str = jdns_string_new();
jdns_string_set_cstr(str, RESVAR.dnsrch[n]);
p = string_tolower(str);
jdns_string_delete(str);
str = p;
// don't add dups
if(!dnsparams_have_domain(params, str))
jdns_dnsparams_append_domain(params, str);
jdns_string_delete(str);
}
}
#endif
return params;
}
