bool HttpClient::downloadBody(const std::string& body_header)
{
const std::string& header = _response->getHeader();
HttpHeaderParser header_parser(header);
bool is_chunked = header_parser.isChunked();
int http_code = header_parser.getHttpCode();
int content_lenght = header_parser.getContentLength();
bool complete = false;
_response->setHttpCode(http_code);
if (is_chunked) //Chunk类型的Http体
{
complete = downloadChunkedBody(body_header);
}
else //带Content-Length的Http体
{
complete = downloadFixedSizeBody(body_header,content_lenght);
}
return complete; //下载完毕
}
gboolean
rawx_client_get_directory_data(rawx_session_t * session, hash_sha256_t chunk_id, struct content_textinfo_s *content,
struct chunk_textinfo_s *chunk, GError ** error)
{
int rc;
gchar str_addr[64];
gsize str_addr_size;
gchar str_req[2048];
gchar str_chunk_id[(sizeof(hash_sha256_t) * 2) + 1];
GHashTable *result = NULL;
GByteArray *buffer = NULL;
ne_request *request = NULL;
if (!session) {
GSETERROR(error, "Invalid parameter");
return FALSE;
}
memset(str_chunk_id, '\0', sizeof(str_chunk_id));
oio_str_bin2hex(chunk_id, sizeof(hash_sha256_t), str_chunk_id, sizeof(str_chunk_id));
memset(str_req, '\0', sizeof(str_req));
snprintf(str_req, sizeof(str_req) - 1, "%s/%s", RAWX_REQ_GET_DIRINFO, str_chunk_id);
ne_set_connect_timeout(session->neon_session, session->timeout.cnx / 1000);
ne_set_read_timeout(session->neon_session, session->timeout.req / 1000);
request = ne_request_create(session->neon_session, "HEAD", str_req);
if (!request) {
GSETERROR(error, "neon request creation error");
return FALSE;
}
buffer = g_byte_array_new();
ne_add_response_body_reader(request, ne_accept_2xx, body_reader, buffer);
switch (rc = ne_request_dispatch(request)) {
case NE_OK:
if (ne_get_status(request)->klass != 2) {
GSETERROR(error, "RAWX returned an error %d : %s",
ne_get_status(request)->code, ne_get_status(request)->reason_phrase);
goto error;
}
else if (!(result = header_parser(request))) {
GSETERROR(error, "No attr from the RAWX server");
goto error;
}
break;
case NE_ERROR:
case NE_TIMEOUT:
case NE_CONNECT:
case NE_AUTH:
str_addr_size = addr_info_to_string(&(session->addr), str_addr, sizeof(str_addr));
GSETERROR(error, "cannot download the data from [%.*s]' (%s)",
(int)str_addr_size, str_addr, ne_get_error(session->neon_session));
goto error;
default:
GSETERROR(error, "Unexpected return code from the neon library : %d", rc);
goto error;
}
g_byte_array_free(buffer, TRUE);
ne_request_destroy(request);
/* Fill the textinfo structs */
parse_chunkinfo_from_rawx(result, content, chunk);
g_hash_table_destroy(result);
return TRUE;
error:
g_byte_array_free(buffer, TRUE);
ne_request_destroy(request);
return FALSE;
}
int nd_parse_proc(struct nd_parse_ctx *npc, void *buf, size_t len)
{
size_t consumed = 0; /* number of bytes in buf consumed by
the current function call */
if (npc->error < 0)
return npc->error;
if (len == 0)
return consumed;
if (!npc->header_parsed) {
int r = header_parser(npc, buf, len);
if (!npc->header_parsed)
return r;
buf += r;
len -= r;
consumed += r;
}
/* if we pass the above if, the header must be parsed.
* Thus, version and nr_total will be populated. */
size_t goal_len;
if (npc->version == 0)
goal_len = sizeof(npc->cur_e_v0);
else if (npc->version == 2)
goal_len = sizeof(npc->cur_e);
else {
npc->error = -EINVAL;
return npc->error;
}
uint32_t nr_total = npc->nr_total;
uint32_t nr;
size_t pos = npc->cur_e_pos;
for (nr = npc->nr_consumed; nr < nr_total; nr++) {
char *start_cpy = (char *)&(npc->cur_e) + pos;
size_t rem = goal_len - pos;
size_t cpy_len = MIN(rem, len);
memcpy(start_cpy, buf, cpy_len);
pos += cpy_len;
len -= cpy_len;
buf += cpy_len;
if (likely(pos == goal_len)) {
/* we filled this entry, deserialize it
* and continue */
struct peer *p = npc->version ?
mk_kad_peer(&npc->cur_e) :
mk_kad_peer_v0(&npc->cur_e_v0);
if (!p) {
/* failed allocation? set npc->error and
* return the consumed bytes. Error will be
* returned on next call */
npc->error = -errno;
npc->nr_consumed = nr;
npc->cur_e_pos = 0;
return consumed;
}
pos = 0;
*(npc->tail) = p;
npc->tail = &(p->next);
consumed += cpy_len;
} else {
/* entry not filled but data done.
* update things for next time */
npc->cur_e_pos = pos;
npc->nr_consumed = nr;
return consumed + cpy_len;
}
}
/* we've read all the nodes in the file */
return consumed;
}
void MainWindow::generateAll ()
{
saveConfiguration ( gen_driver_container () );
saveExistConfiguration ( existingProjectFolders() );
QDir dir;
if ( !dir.exists("files") ) {
dir.mkdir("files");
dir.cd("files");
}
else {
if ( dir.cd ("files") )
clear_dir (dir);
}
//HeaderConfig header_conf;
GroupsContainerType groups_container;
//StructsParser stru_parser( groups_container, rules_declarations, header_conf );
//stru_parser.parse ("ConfMaker3.xml");
DeclarationParser stru_parser( groups_container );
stru_parser.parse ("xml/ConfMaker3.xml");
// HeaderDefParser header_parser (header_conf);
// header_parser.parse ("xml/header_defs.xml");
QList<GeneratedDriversContainer> net_containers;
QList<GeneratedDriversContainer> pribor_containers;
QList<GeneratedDriversContainer> prot_containers;
QList<GeneratedDriversContainer> alarm_containers;
SigsProj sigs_proj;
for (GenDriverConfContainer::iterator iter_dr = gen_driver_container().begin(); iter_dr != gen_driver_container().end(); ++iter_dr ) {
for (GenDeviceConfContainer::iterator iter_dev = (*iter_dr).devices().begin(); iter_dev != (*iter_dr).devices().end(); ++iter_dev ) {
RulesDeclarationContainerType rules_declarations;
LocalGenerator local_gen (groups_container, rules_declarations);
HeaderConfig header_conf;
QString sigs_path = (*iter_dev).genItemsConf()["sigs_path"].toUrl().toLocalFile();
QString defin_path = (*iter_dev).genItemsConf()["definitions"].toUrl().toLocalFile();
QString defs_path = (*iter_dev).genItemsConf()["defs"].toUrl().toLocalFile();
bool gen_wnd = (*iter_dev).genItemsConf()["gen_wnd"].toBool();
DefinitionParser defin_parser(rules_declarations);
defin_parser.parse (defin_path);
HeaderDefParser header_parser (header_conf);
header_parser.parse (defs_path);
sigs_proj.append ( SigsContainer() );
SigsParser parser( sigs_proj.last() );
parser.parse(sigs_path);
GeneratedDefinitionsContainer rules_definition_cont;
local_gen.setDefinitionsContainer ( &rules_definition_cont );
local_gen.setSigsContainer (&sigs_proj.last() );
net_containers.append ( GeneratedDriversContainer() );
local_gen.generate( net_containers.last (), "unit_conf", bind (fill_unit_conf, _1, _2, *iter_dr, *iter_dev) );
OffsetGenerator offs_gen(net_containers.last ());
offs_gen.generate ();
pribor_containers.append ( GeneratedDriversContainer() );
local_gen.generate( pribor_containers.last (), "pribor_conf", fill_generic );
prot_containers.append ( GeneratedDriversContainer() );
local_gen.generate( prot_containers.last (), "prot_conf", fill_generic );
alarm_containers.append ( GeneratedDriversContainer() );
local_gen.generate( alarm_containers.last (), "alarm_conf", fill_generic );
const QString& proj_name = sigs_proj.last().findSection ("PROJ").first().first();
QDir proj_dir ("files");
if ( !proj_dir.exists(proj_name) ) {
proj_dir.mkdir (proj_name);
}
proj_dir.cd (proj_name);
DefinesGenerator def_gen ( sigs_proj.last(), rules_definition_cont, header_conf);
Defines defines;
def_gen.generate (defines);
DefinesSaver defines_saver (defines);
defines_saver.save (proj_dir.path() + "/" + header_conf.fileName );
TemplateParser tpl_parser ( sigs_proj.last() );
tpl_parser.parse ("tpl/user_func.c.template" , proj_dir.path() + "/user_func.c");
tpl_parser.parse ("tpl/user_func.h.template" , proj_dir.path() + "/user_func.h");
tpl_parser.parse ("tpl/task.QCC.template" , proj_dir.path() + "/task.QCC" );
tpl_parser.parse ("tpl/net.QCC.template" , proj_dir.path() + "/net.QCC" );
tpl_parser.parse ("tpl/user_net.c.template" , proj_dir.path() + "/user_net.c" );
tpl_parser.parse ("tpl/globallists.xml.template", proj_dir.path() + "/globallists.xml");
if ( gen_wnd ) {
FullAiConfWindow full_ai_w( sigs_proj.last(), rules_definition_cont );
full_ai_w.generate(proj_dir.path());
}
}
}
// tpl_parser.parse ("tpl/globallists.xml.template", "files/globallists.xml");
QStringList & exf = existingProjectFolders();
ExistingParserRunner runner;
for ( auto f : exf ) {
{
net_containers.append(GeneratedDriversContainer());
ExistingUnitConfParser p(net_containers.last());
runner.parse(f + "/unit_conf.txt", p);
}
{
prot_containers.append(GeneratedDriversContainer());
//auto prc = [](const QString& s){return s;};
auto prc = [](const QString& s){return s.left(s.lastIndexOf(","));};
ExistingConfParser<decltype(prc)> p(prot_containers.last(), std::move(prc));
runner.parse(f + "/prot_conf.txt", p);
}
{
pribor_containers.append(GeneratedDriversContainer());
auto prc = [](const QString& s){return s.left(s.lastIndexOf(","));};
ExistingConfParser<decltype(prc)> p(pribor_containers.last(), std::move(prc));
runner.parse(f + "/pribor_conf.txt", p);
}
{
alarm_containers.append(GeneratedDriversContainer());
auto prc = [](const QString& s){return s.right(s.length() - s.indexOf(",") - 1);};
ExistingConfParser<decltype(prc)> p(alarm_containers.last(), std::move(prc));
runner.parse(f + "/alarm_conf.txt", p);
}
}
ConfSaver saver ( net_containers );
saver.save< IntToType<UnitConf> > ("files/unit_conf.txt");
ConfSaver prb_saver( pribor_containers );
prb_saver.save< IntToType<PriborConf> > ("files/pribor_conf.txt");
ConfSaver prot_saver( prot_containers );
prot_saver.save <IntToType <ProtConf> >("files/prot_conf.txt");
ConfSaver alarm_saver( alarm_containers );
alarm_saver.save <IntToType <AlarmConf> >("files/alarm_conf.txt");
ConfSaver panel_conf_header_saver( net_containers );
panel_conf_header_saver.save < IntToType <PanelConfHeader> >("files/groups.h");
panel_conf_header_saver.save < IntToType <PanelConfDefinition> >("files/groups.c");
qDebug () << "Ok";
//FakeTable f;
}
