const FontFace* Font::GetFaceTTF(int pointSize)
{
// Create & initialize FreeType library if it does not exist yet
FreeTypeLibrary* freeType = GetSubsystem<FreeTypeLibrary>();
if (!freeType)
context_->RegisterSubsystem(freeType = new FreeTypeLibrary(context_));
FT_Face face;
FT_Error error;
FT_Library library = freeType->GetLibrary();
if (pointSize <= 0)
{
LOGERROR("Zero or negative point size");
return 0;
}
if (!fontDataSize_)
{
LOGERROR("Font not loaded");
return 0;
}
error = FT_New_Memory_Face(library, &fontData_[0], fontDataSize_, 0, &face);
if (error)
{
LOGERROR("Could not create font face");
return 0;
}
error = FT_Set_Char_Size(face, 0, pointSize * 64, FONT_DPI, FONT_DPI);
if (error)
{
FT_Done_Face(face);
LOGERROR("Could not set font point size " + String(pointSize));
return 0;
}
SharedPtr<FontFace> newFace(new FontFace());
FT_GlyphSlot slot = face->glyph;
unsigned numGlyphs = 0;
// Build glyph mapping
FT_UInt glyphIndex;
FT_ULong charCode = FT_Get_First_Char(face, &glyphIndex);
while (glyphIndex != 0)
{
numGlyphs = Max((int)glyphIndex + 1, (int)numGlyphs);
newFace->glyphMapping_[charCode] = glyphIndex;
charCode = FT_Get_Next_Char(face, charCode, &glyphIndex);
}
LOGDEBUG("Font face has " + String(numGlyphs) + " glyphs");
// Load each of the glyphs to see the sizes & store other information
int maxHeight = 0;
FT_Pos ascender = face->size->metrics.ascender;
newFace->glyphs_.Reserve(numGlyphs);
for (unsigned i = 0; i < numGlyphs; ++i)
{
FontGlyph newGlyph;
error = FT_Load_Glyph(face, i, FT_LOAD_DEFAULT);
if (!error)
{
// Note: position within texture will be filled later
newGlyph.width_ = (short)((slot->metrics.width) >> 6);
newGlyph.height_ = (short)((slot->metrics.height) >> 6);
newGlyph.offsetX_ = (short)((slot->metrics.horiBearingX) >> 6);
newGlyph.offsetY_ = (short)((ascender - slot->metrics.horiBearingY) >> 6);
newGlyph.advanceX_ = (short)((slot->metrics.horiAdvance) >> 6);
maxHeight = Max(maxHeight, newGlyph.height_);
}
else
{
int _ds_degenerate_message(DSPAM_CTX *CTX, buffer * header, buffer * body)
{
char *decode = NULL;
struct nt_node *node_nt, *node_header;
struct nt_c c_nt, c_nt2;
int i = 0;
char heading[1024];
if (! CTX->message)
{
LOG (LOG_WARNING, "_ds_degenerate_message() failed: CTX->message is NULL");
return EUNKNOWN;
}
/* Iterate through each component and create large header/body buffers */
node_nt = c_nt_first (CTX->message->components, &c_nt);
while (node_nt != NULL)
{
struct _ds_message_part *block = (struct _ds_message_part *) node_nt->ptr;
#ifdef VERBOSE
LOGDEBUG ("Processing component %d", i);
#endif
if (! block->headers || ! block->headers->items)
{
#ifdef VERBOSE
LOGDEBUG (" : End of Message Identifier");
#endif
}
else
{
struct _ds_header_field *current_header;
/* Accumulate the headers */
node_header = c_nt_first (block->headers, &c_nt2);
while (node_header != NULL)
{
current_header = (struct _ds_header_field *) node_header->ptr;
snprintf (heading, sizeof (heading),
"%s: %s\n", current_header->heading,
current_header->data);
buffer_cat (header, heading);
node_header = c_nt_next (block->headers, &c_nt2);
}
decode = block->body->data;
if (block->media_type == MT_TEXT ||
block->media_type == MT_MESSAGE ||
block->media_type == MT_UNKNOWN ||
(block->media_type == MT_MULTIPART && !i))
{
/* Accumulate the bodies, skip attachments */
if (
( block->encoding == EN_BASE64
|| block->encoding == EN_QUOTED_PRINTABLE)
&& ! block->original_signed_body)
{
if (block->content_disposition != PCD_ATTACHMENT)
{
LOGDEBUG ("decoding message block from encoding type %d",
block->encoding);
decode = _ds_decode_block (block);
}
}
/* We found a tokenizable body component, add prefilters */
if (decode)
{
char *decode2 = NULL;
char *decode3 = NULL;
/* -- PREFILTERS BEGIN -- */
/* Hexadecimal 8-Bit Encodings */
if (block->encoding == EN_8BIT) {
decode2 = _ds_decode_hex8bit(decode);
} else {
decode2 = strdup(decode);
}
/* HTML-Specific Filters */
if (decode2) {
if (block->media_subtype == MST_HTML) {
decode3 = _ds_strip_html(decode2);
} else {
decode3 = strdup(decode2);
}
free(decode2);
}
/* -- PREFILTERS END -- */
if (decode3) {
buffer_cat (body, decode3);
free(decode3);
}
/* If we've decoded the body, save the original copy */
if (decode != block->body->data)
{
block->original_signed_body = block->body;
block->body = buffer_create (decode);
free (decode);
}
}
}
}
#ifdef VERBOSE
LOGDEBUG ("Getting next message component");
#endif
node_nt = c_nt_next (CTX->message->components, &c_nt);
i++;
} /* while (node_nt != NULL) */
if (header->data == NULL)
buffer_cat (header, " ");
if (body->data == NULL)
buffer_cat (body, " ");
return 0;
}
//!
//!
//!
//! @param[in] inst a pointer to the instance structure
//! @param[in] in a transparent pointer (unused)
//!
//! @return
//!
//! @pre The inst pointer must not be NULL.
//!
//! @note
//!
int instIpSync(ccInstance * inst, void *in)
{
int ret = 0;
if (!inst) {
return (1);
} else if ((strcmp(inst->state, "Pending") && strcmp(inst->state, "Extant"))) {
return (0);
}
LOGDEBUG("instanceId=%s CCpublicIp=%s CCprivateIp=%s CCprivateMac=%s CCvlan=%d CCnetworkIndex=%d NCpublicIp=%s NCprivateIp=%s NCprivateMac=%s "
"NCvlan=%d NCnetworkIndex=%d\n", inst->instanceId, inst->ccnet.publicIp, inst->ccnet.privateIp, inst->ccnet.privateMac, inst->ccnet.vlan,
inst->ccnet.networkIndex, inst->ncnet.publicIp, inst->ncnet.privateIp, inst->ncnet.privateMac, inst->ncnet.vlan, inst->ncnet.networkIndex);
if (inst->ccnet.vlan == 0 && inst->ccnet.networkIndex == 0 && inst->ccnet.publicIp[0] == '\0' && inst->ccnet.privateIp[0] == '\0' && inst->ccnet.privateMac[0] == '\0') {
// ccnet is completely empty, make a copy of ncnet
LOGDEBUG("ccnet is empty, copying ncnet\n");
memcpy(&(inst->ccnet), &(inst->ncnet), sizeof(netConfig));
return (1);
}
// IP cases
// 1.) local CC cache has no IP info for VM, NC VM has no IP info
// - do nothing
// 2.) local CC cache has no IP info, NC VM has IP info
// - ingress NC info, kick_network
// 3.) local CC cache has IP info, NC VM has no IP info
// - send ncAssignAddress
// 4.) local CC cache has IP info, NC VM has different IP info
// - ingress NC info, kick_network
// 5.) local CC cache has IP info, NC VM has same IP info
// - do nothing
if ((inst->ccnet.publicIp[0] == '\0' || !strcmp(inst->ccnet.publicIp, "0.0.0.0"))
&& (inst->ncnet.publicIp[0] != '\0' && strcmp(inst->ncnet.publicIp, "0.0.0.0"))) {
// case 2
LOGDEBUG("CC publicIp is empty, NC publicIp is set\n");
snprintf(inst->ccnet.publicIp, INET_ADDR_LEN, "%s", inst->ncnet.publicIp);
ret++;
} else if (((inst->ccnet.publicIp[0] != '\0' && strcmp(inst->ccnet.publicIp, "0.0.0.0"))
&& (inst->ncnet.publicIp[0] != '\0' && strcmp(inst->ncnet.publicIp, "0.0.0.0")))
&& strcmp(inst->ccnet.publicIp, inst->ncnet.publicIp)) {
// case 4
LOGDEBUG("CC publicIp and NC publicIp differ\n");
snprintf(inst->ccnet.publicIp, INET_ADDR_LEN, "%s", inst->ncnet.publicIp);
ret++;
}
// VLAN cases
if (inst->ccnet.vlan != inst->ncnet.vlan) {
// problem
LOGERROR("CC and NC vlans differ instanceId=%s CCvlan=%d NCvlan=%d\n", inst->instanceId, inst->ccnet.vlan, inst->ncnet.vlan);
}
inst->ccnet.vlan = inst->ncnet.vlan;
// networkIndex cases
if (inst->ccnet.networkIndex != inst->ncnet.networkIndex) {
// problem
LOGERROR("CC and NC networkIndicies differ instanceId=%s CCnetworkIndex=%d NCnetworkIndex=%d\n", inst->instanceId, inst->ccnet.networkIndex, inst->ncnet.networkIndex);
}
inst->ccnet.networkIndex = inst->ncnet.networkIndex;
// mac addr cases
if (strcmp(inst->ccnet.privateMac, inst->ncnet.privateMac)) {
// problem;
LOGERROR("CC and NC mac addrs differ instanceId=%s CCmac=%s NCmac=%s\n", inst->instanceId, inst->ccnet.privateMac, inst->ncnet.privateMac);
}
snprintf(inst->ccnet.privateMac, ENET_ADDR_LEN, "%s", inst->ncnet.privateMac);
// privateIp cases
if (strcmp(inst->ccnet.privateIp, inst->ncnet.privateIp)) {
// sync em
snprintf(inst->ccnet.privateIp, INET_ADDR_LEN, "%s", inst->ncnet.privateIp);
}
return (ret);
}
int
dspam_init_driver (DRIVER_CTX *DTX)
{
DSPAM_CTX *CTX;
char *HashConcurrentUser;
#ifdef DAEMON
unsigned long connection_cache = 1;
#endif
if (DTX == NULL)
return 0;
CTX = DTX->CTX;
HashConcurrentUser = READ_ATTRIB("HashConcurrentUser");
#ifdef DAEMON
/*
* Stateful concurrent hash databases are preloaded into memory and
* shared using a reader-writer lock. At the present moment, only a single
* user can be loaded into any instance of the daemon, so it is only useful
* if you are running with a system-wide filtering user.
*/
if (DTX->flags & DRF_STATEFUL) {
char filename[MAX_FILENAME_LENGTH];
hash_drv_map_t map;
unsigned long hash_rec_max = HASH_REC_MAX;
unsigned long max_seek = HASH_SEEK_MAX;
unsigned long max_extents = 0;
unsigned long extent_size = HASH_EXTENT_MAX;
int pctincrease = 0;
int flags = HMAP_AUTOEXTEND;
int ret, i;
if (READ_ATTRIB("HashConnectionCache") && !HashConcurrentUser)
connection_cache = strtol(READ_ATTRIB("HashConnectionCache"), NULL, 0);
DTX->connection_cache = connection_cache;
if (READ_ATTRIB("HashRecMax"))
hash_rec_max = strtol(READ_ATTRIB("HashRecMax"), NULL, 0);
if (READ_ATTRIB("HashExtentSize"))
extent_size = strtol(READ_ATTRIB("HashExtentSize"), NULL, 0);
if (READ_ATTRIB("HashMaxExtents"))
max_extents = strtol(READ_ATTRIB("HashMaxExtents"), NULL, 0);
if (!MATCH_ATTRIB("HashAutoExtend", "on"))
flags = 0;
if (READ_ATTRIB("HashPctIncrease")) {
pctincrease = atoi(READ_ATTRIB("HashPctIncrease"));
if (pctincrease > 100) {
LOG(LOG_ERR, "HashPctIncrease out of range; ignoring");
pctincrease = 0;
}
}
if (READ_ATTRIB("HashMaxSeek"))
max_seek = strtol(READ_ATTRIB("HashMaxSeek"), NULL, 0);
/* Connection array (just one single connection for hash_drv) */
DTX->connections = calloc(1, sizeof(struct _ds_drv_connection *) * connection_cache);
if (DTX->connections == NULL)
goto memerr;
/* Initialize Connections */
for(i=0;i<connection_cache;i++) {
DTX->connections[i] = calloc(1, sizeof(struct _ds_drv_connection));
if (DTX->connections[i] == NULL)
goto memerr;
/* Our connection's storage structure */
if (HashConcurrentUser) {
DTX->connections[i]->dbh = calloc(1, sizeof(struct _hash_drv_map));
if (DTX->connections[i]->dbh == NULL)
goto memerr;
pthread_rwlock_init(&DTX->connections[i]->rwlock, NULL);
} else {
DTX->connections[i]->dbh = NULL;
pthread_mutex_init(&DTX->connections[i]->lock, NULL);
}
}
/* Load concurrent database into resident memory */
if (HashConcurrentUser) {
map = (hash_drv_map_t) DTX->connections[0]->dbh;
/* Tell the server our connection lock will be reader/writer based */
if (!(DTX->flags & DRF_RWLOCK))
DTX->flags |= DRF_RWLOCK;
_ds_userdir_path(filename, DTX->CTX->home, HashConcurrentUser, "css");
_ds_prepare_path_for(filename);
LOGDEBUG("preloading %s into memory via mmap()", filename);
ret = _hash_drv_open(filename, map, hash_rec_max,
max_seek, max_extents, extent_size, pctincrease, flags);
if (ret) {
LOG(LOG_CRIT, "_hash_drv_open(%s) failed on error %d: %s",
filename, ret, strerror(errno));
free(DTX->connections[0]->dbh);
free(DTX->connections[0]);
free(DTX->connections);
return EFAILURE;
}
}
}
#endif
return 0;
#ifdef DAEMON
memerr:
if (DTX) {
if (DTX->connections) {
int i;
for(i=0;i<connection_cache;i++) {
if (DTX->connections[i])
free(DTX->connections[i]->dbh);
free(DTX->connections[i]);
}
}
free(DTX->connections);
}
LOG(LOG_CRIT, ERR_MEM_ALLOC);
return EUNKNOWN;
#endif
}
int main(int argc, char**argv) {
Log::open();
org::esb::io::File fbp(argv[0]);
std::string base_path = org::esb::io::File(fbp.getParent()).getParent();
org::esb::config::Config::setProperty("web.docroot",base_path);
org::esb::api::ApiWebServer api_server(8888);
org::esb::api::ProcessHandler proc_handler;
api_server.addHandler(&proc_handler);
org::esb::lang::CtrlCHitWaiter::wait();
//return 0;
/*first find out if there is running a server*/
org::esb::grid::Node node;
node.setData("type", "searcher");
org::esb::grid::NodeResolver res(boost::asio::ip::address::from_string("0.0.0.0"), boost::asio::ip::address::from_string("239.255.0.1"), 6000, node);
res.start();
LOGDEBUG("Waiting 3 secs. to find all online nodes");
org::esb::lang::Thread::sleep2(3000);
org::esb::grid::NodeResolver::NodeList nodes = res.getNodes();
org::esb::grid::NodeResolver::NodeList::iterator nodeit = nodes.begin();
bool server_running = false;
int client_count = 0;
std::string host;
int port=0;
for (; nodeit != nodes.end(); nodeit++) {
LOGDEBUG((*nodeit)->toString());
LOGDEBUG("NodeType" << (*nodeit)->getData("type"));
if ((*nodeit)->getData("type") == "server"){
server_running = true;
host = (*nodeit)->getIpAddress().to_string();
port = atoi((*nodeit)->getData("port").c_str());
}
if ((*nodeit)->getData("type") == "client")
client_count++;
}
res.stop();
/**
* needing the base path from the executable
* */
int mode = 0;
org::esb::io::File f(argv[0]);
std::cout << f.getParent() << std::endl;
std::string path = f.getParent();
std::string bpath = f.getParent();
bpath.append("/..");
std::string executable = path;
std::list<std::string> arguments;
org::esb::io::File file(path.append("/../hive"));
if (!file.exists()) {
file.mkdir();
mode = 1;
}
#ifdef WIN32
executable.append("/mhive.exe ");
//replacing all slashes with backslashes
int position = executable.find("/"); // find first slash
while (position != string::npos) {
executable.replace(position, 1, "\\");
position = executable.find("/", position + 1);
}
#else
executable.append("/mhive");
#endif
PListener listener;
/*create internal database*/
if(mode==1){
arguments.clear();
arguments.push_back("--install");
arguments.push_back("--base="+bpath);
LOGINFO("Create mhive database")
org::esb::lang::Process prinst(executable, arguments, "mhiveinstaller");
prinst.start();
}
#ifdef USE_SAFMQ
arguments.clear();
arguments.push_back("-q");
arguments.push_back("--base="+bpath);
//arguments.push_back("--debugmode");
LOGINFO("Starting mhive queue")
org::esb::lang::Process prq(executable, arguments, "mhivequeue");
// PListener listener;
//prq.addProcessListener(&listener);
prq.run();
#endif
LOGINFO("Starting mhive webadmin")
arguments.clear();
arguments.push_back("-w");
arguments.push_back("--base="+bpath);
org::esb::lang::Process prw(executable, arguments,"mhiveweb");
//prw.addProcessListener(&listener);
prw.run();
org::esb::lang::Process * pra=NULL;
org::esb::lang::Process * prc=NULL;
if(!server_running){
LOGINFO("Starting mhive core service")
arguments.clear();
arguments.push_back("-r");
arguments.push_back("--base="+bpath);
//arguments.push_back("--debugmode");
pra=new org::esb::lang::Process(executable, arguments,"mhivecore");
//PListener listener;
//pra.addProcessListener(&listener);
pra->run();
org::esb::lang::Thread::sleep2(2000);
LOGINFO("Starting mhive client")
LOGINFO("Client host="<<host<<" port="<<port);
arguments.clear();
arguments.push_back("-i");
// arguments.push_back("-h 127.0.0.1");
//arguments.push_back("-p "+org::esb::util::StringUtil::toString(port));
//arguments.push_back("--base="+bpath);
//arguments.push_back("--debugmode");
prc=new org::esb::lang::Process(executable, arguments,"mhiveclient");
//PListener listener;
//pra.addProcessListener(&listener);
prc->run();
}else{
LOGINFO("Starting mhive client")
arguments.clear();
arguments.push_back("-i");
// arguments.push_back("-h "+host);
// arguments.push_back("-p "+org::esb::util::StringUtil::toString(port));
arguments.push_back("--base="+bpath);
//arguments.push_back("--debugmode");
prc=new org::esb::lang::Process(executable, arguments,"mhiveclient");
//PListener listener;
//pra.addProcessListener(&listener);
prc->run();
}
open_dialog("Media Encoding Cluster Server is running please open the webpage on http://localhost:8080 now","msgbox");
arguments.clear();
arguments.push_back("http://localhost:8080");
// org::esb::lang::Thread::sleep2(1000);
open_webadmin();
org::esb::lang::CtrlCHitWaiter::wait();
open_dialog("Media Encoding Cluster\nStop signal received!\nhalting now","msgbox");
try {
pra->stop();
} catch (org::esb::lang::ProcessException & ex) {
try {
pra->kill();
} catch (org::esb::lang::ProcessException & ex) {
LOGERROR("Exception:" << ex.what());
}
}
delete pra;
try {
prc->stop();
} catch (org::esb::lang::ProcessException & ex) {
try {
prc->kill();
} catch (org::esb::lang::ProcessException & ex) {
LOGERROR("Exception:" << ex.what());
}
}
delete prc;
try {
prw.stop();
} catch (org::esb::lang::ProcessException & ex) {
try {
prw.kill();
} catch (org::esb::lang::ProcessException & ex) {
LOGERROR("Exception:" << ex.what());
}
}
#ifdef USE_SAFMQ
try {
prq.stop();
} catch (org::esb::lang::ProcessException & ex) {
try {
prq.kill();
} catch (org::esb::lang::ProcessException & ex) {
LOGERROR("Exception:" << ex.what());
}
}
#endif
open_dialog("Media Encoding Cluster stopped!","msgbox");
}
//!
//!
//!
//! @param[in] pMeta a pointer to the node controller (NC) metadata structure
//! @param[in] serviceIds a list of service info.
//! @param[in] serviceIdsLen the number of service info in the serviceIds list
//! @param[out] outStatuses list of service status
//! @param[out] outStatusesLen number of service status in the outStatuses list
//!
//! @return
//!
//! @pre
//!
//! @note
//!
int doDescribeServices(ncMetadata * pMeta, serviceInfoType * serviceIds, int serviceIdsLen, serviceStatusType ** outStatuses, int *outStatusesLen)
{
int rc = 0;
int i = 0;
int j = 0;
int port = 0;
char uri[EUCA_MAX_PATH] = { 0 };
char uriType[32] = { 0 };
char host[EUCA_MAX_PATH] = { 0 };
char path[EUCA_MAX_PATH] = { 0 };
serviceStatusType *myStatus = NULL;
int do_report_cluster = 1; // always do report on the cluster, otherwise CC won't get ENABLED
int do_report_nodes = 0;
int do_report_all = 0;
char *my_partition = NULL;
rc = initialize(pMeta, TRUE); // DescribeServices is the only authoritative source of epoch
if (rc) {
return (1);
}
LOGDEBUG("invoked: userId=%s, serviceIdsLen=%d\n", SP(pMeta ? pMeta->userId : "UNKNOWN"), serviceIdsLen);
//! @TODO for now, return error if list of services is passed in as parameter
/*
if (serviceIdsLen > 0) {
LOGERROR("DescribeServices(): received non-zero number of input services, returning fail\n");
*outStatusesLen = 0;
*outStatuses = NULL;
return(1);
}
*/
sem_mywait(CONFIG);
{
if (!strcmp(config->ccStatus.serviceId.name, "self")) {
for (i = 0; i < serviceIdsLen; i++) {
LOGDEBUG("received input serviceId[%d]\n", i);
if (strlen(serviceIds[i].type)) {
if (!strcmp(serviceIds[i].type, "cluster")) {
snprintf(uri, EUCA_MAX_PATH, "%s", serviceIds[i].uris[0]);
rc = tokenize_uri(uri, uriType, host, &port, path);
if (strlen(host)) {
LOGDEBUG("setting local serviceId to input serviceId (type=%s name=%s partition=%s)\n",
SP(serviceIds[i].type), SP(serviceIds[i].name), SP(serviceIds[i].partition));
memcpy(&(config->ccStatus.serviceId), &(serviceIds[i]), sizeof(serviceInfoType));
}
} else if (!strcmp(serviceIds[i].type, "node")) {
do_report_nodes = 1; // report on node services if requested explicitly
}
}
}
}
}
sem_mypost(CONFIG);
if (serviceIdsLen < 1) { // if the describe request is not specific, report on everything
do_report_cluster = 1;
do_report_nodes = 1;
do_report_all = 1;
} else { // if the describe request is specific, identify which types are requested
do_report_cluster = 0;
do_report_nodes = 0;
do_report_all = 0;
for (i = 0; i < serviceIdsLen; i++) {
LOGDEBUG("received input serviceId[%d]: %s %s %s %s\n", i, serviceIds[i].type, serviceIds[i].partition, serviceIds[i].name, serviceIds[i].uris[0]);
if (strlen(serviceIds[i].type)) {
if (!strcmp(serviceIds[i].type, "cluster")) {
do_report_cluster = 1; // report on cluster services if requested explicitly
} else if (!strcmp(serviceIds[i].type, "node")) {
do_report_nodes++; // count number of and report on node services if requested explicitly
}
}
}
}
for (i = 0; i < 16; i++) {
if (strlen(config->services[i].type)) {
LOGDEBUG("internal serviceInfos type=%s name=%s partition=%s urisLen=%d\n", config->services[i].type,
config->services[i].name, config->services[i].partition, config->services[i].urisLen);
if (!strcmp(config->services[i].type, "cluster")) {
my_partition = config->services[i].partition;
}
for (j = 0; j < MAX_SERVICE_URIS; j++) {
if (strlen(config->services[i].uris[j])) {
LOGDEBUG("internal serviceInfos\t uri[%d]:%s\n", j, config->services[i].uris[j]);
}
}
}
}
for (i = 0; i < 16; i++) {
if (strlen(config->disabledServices[i].type)) {
LOGDEBUG("internal disabled serviceInfos type=%s name=%s partition=%s urisLen=%d\n", config->disabledServices[i].type,
config->disabledServices[i].name, config->disabledServices[i].partition, config->disabledServices[i].urisLen);
for (j = 0; j < MAX_SERVICE_URIS; j++) {
if (strlen(config->disabledServices[i].uris[j])) {
LOGDEBUG("internal disabled serviceInfos\t uri[%d]:%s\n", j, config->disabledServices[i].uris[j]);
}
}
}
}
for (i = 0; i < 16; i++) {
if (strlen(config->notreadyServices[i].type)) {
LOGDEBUG("internal not ready serviceInfos type=%s name=%s partition=%s urisLen=%d\n", config->notreadyServices[i].type,
config->notreadyServices[i].name, config->notreadyServices[i].partition, config->notreadyServices[i].urisLen);
for (j = 0; j < MAX_SERVICE_URIS; j++) {
if (strlen(config->notreadyServices[i].uris[j])) {
LOGDEBUG("internal not ready serviceInfos\t uri[%d]:%s\n", j, config->notreadyServices[i].uris[j]);
}
}
}
}
*outStatusesLen = 0;
*outStatuses = NULL;
if (do_report_cluster) {
(*outStatusesLen) += 1;
*outStatuses = EUCA_ZALLOC(1, sizeof(serviceStatusType));
if (!*outStatuses) {
LOGFATAL("out of memory!\n");
unlock_exit(1);
}
myStatus = *outStatuses;
snprintf(myStatus->localState, 32, "%s", config->ccStatus.localState); // ENABLED, DISABLED, STOPPED, NOTREADY
snprintf(myStatus->details, 1024, "%s", config->ccStatus.details); // string that gets printed by 'euca-describe-services -E'
myStatus->localEpoch = config->ccStatus.localEpoch;
memcpy(&(myStatus->serviceId), &(config->ccStatus.serviceId), sizeof(serviceInfoType));
LOGDEBUG("external services\t uri[%d]: %s %s %s %s %s\n",
0, myStatus->serviceId.type, myStatus->serviceId.partition, myStatus->serviceId.name, myStatus->localState, myStatus->serviceId.uris[0]);
}
if (do_report_nodes) {
extern ccResourceCache *resourceCache;
ccResourceCache resourceCacheLocal;
sem_mywait(RESCACHE);
memcpy(&resourceCacheLocal, resourceCache, sizeof(ccResourceCache));
sem_mypost(RESCACHE);
if (resourceCacheLocal.numResources > 0 && my_partition != NULL) { // parition is unknown at early stages of CC initialization
for (int idIdx = 0; idIdx < serviceIdsLen; idIdx++) {
if (do_report_all || !strcmp(serviceIds[idIdx].type, "node")) {
for (int rIdx = 0; rIdx < resourceCacheLocal.numResources; rIdx++) {
ccResource *r = resourceCacheLocal.resources + rIdx;
if (do_report_all || (strlen(serviceIds[idIdx].name) && strlen(r->ip) && !strcmp(serviceIds[idIdx].name, r->ip))) {
// we have a node that we want to report about
(*outStatusesLen) += 1;
*outStatuses = EUCA_REALLOC(*outStatuses, *outStatusesLen, sizeof(serviceStatusType));
if (*outStatuses == NULL) {
LOGFATAL("out of memory! (outStatusesLen=%d)\n", *outStatusesLen);
unlock_exit(1);
}
myStatus = *outStatuses + *outStatusesLen - 1;
{
int resState = r->state;
int resNcState = r->ncState;
char *state = "BUGGY";
char *msg = "";
if (resState == RESUP) {
if (resNcState == ENABLED) {
state = "ENABLED";
msg = "the node is operating normally";
} else if (resNcState == STOPPED) {
state = "STOPPED";
msg = "the node is not accepting new instances";
} else if (resNcState == NOTREADY) {
state = "NOTREADY";
if (strnlen(r->nodeMessage, 1024)) {
msg = r->nodeMessage;
} else {
msg = "the node is currently experiencing problems and needs attention";
}
}
} else if (resState == RESASLEEP || resState == RESWAKING) {
state = "NOTREADY";
msg = "the node is currently in the sleep state";
} else if (resState == RESDOWN) {
state = "NOTREADY";
if (strnlen(r->nodeMessage, 1024)) {
msg = r->nodeMessage;
} else {
msg = "the node is not responding to the cluster controller";
}
}
snprintf(myStatus->localState, 32, "%s", state);
snprintf(myStatus->details, 1024, "%s", msg); // string that gets printed by 'euca-describe-services -E'
}
myStatus->localEpoch = config->ccStatus.localEpoch;
sprintf(myStatus->serviceId.type, "node");
sprintf(myStatus->serviceId.name, r->hostname);
sprintf(myStatus->serviceId.partition, config->ccStatus.serviceId.partition);
sprintf(myStatus->serviceId.uris[0], r->ncURL);
myStatus->serviceId.urisLen = 1;
LOGDEBUG("external services\t uri[%d]: %s %s %s %s %s\n",
idIdx, myStatus->serviceId.type, myStatus->serviceId.partition, myStatus->serviceId.name, myStatus->localState, myStatus->serviceId.uris[0]);
}
}
}
}
}
}
LOGDEBUG("done\n");
return (0);
}
int daemon_listen(DRIVER_CTX *DTX) {
struct sockaddr_in local_addr, remote_addr;
THREAD_CTX *TTX = NULL;
fd_set master, read_fds;
pthread_attr_t attr;
struct timeval tv;
int fdmax, yes = 1;
int domain = 0; /* listening on domain socket? */
int listener; /* listener fd */
int i;
int port = 24, queue = 32; /* default port and queue size */
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, process_signal);
signal(SIGTERM, process_signal);
signal(SIGHUP, process_signal);
if (_ds_read_attribute(agent_config, "ServerPort"))
port = atoi(_ds_read_attribute(agent_config, "ServerPort"));
if (_ds_read_attribute(agent_config, "ServerQueueSize"))
queue = atoi(_ds_read_attribute(agent_config, "ServerQueueSize"));
if (_ds_read_attribute(agent_config, "ServerDomainSocketPath"))
domain = 1;
/* initialize */
FD_ZERO(&master);
FD_ZERO(&read_fds);
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
/* Bind (domain socket) */
if (domain) {
struct sockaddr_un saun;
char *address = strdup(_ds_read_attribute(agent_config, "ServerDomainSocketPath"));
mode_t mask;
int len;
mask = umask (000);
if (_ds_match_attribute(agent_config, "ServerDomainSymlink", "on")) {
/* treat ServerDomainSymlink as a symlink path */
char* old_address = address;
address = malloc(sizeof(char) * (strlen(address) + 8));
sprintf(address, "%s.%d", old_address, getpid());
free(old_address);
/* address now points to the actual socket, ending in pid */
}
listener = socket(AF_UNIX, SOCK_STREAM, 0);
if (listener == -1) {
LOG(LOG_CRIT, ERR_DAEMON_SOCKET, strerror(errno));
umask (mask);
return(EFAILURE);
}
memset(&saun, 0, sizeof(struct sockaddr_un));
saun.sun_family = AF_UNIX;
strcpy(saun.sun_path, address);
unlink(address);
len = sizeof(saun.sun_family) + strlen(saun.sun_path) + 1;
LOGDEBUG(INFO_DAEMON_DOMAINSOCK, address);
if (bind(listener, (struct sockaddr *) &saun, len)<0) {
close(listener);
LOG(LOG_CRIT, INFO_DAEMON_DOMAINSOCK, address, strerror(errno));
umask (mask);
return EFAILURE;
}
if (_ds_match_attribute(agent_config, "ServerDomainSymlink", "on")) {
/* install symlink for the domain socket */
char *link_address = _ds_read_attribute(agent_config, "ServerDomainSocketPath");
/* to atomically replace the socket symlink, make the symlink elsewhere then move it */
char* new_link_address = malloc(sizeof(char) * (strlen(link_address) + 4));
sprintf(new_link_address, "%s.new", link_address);
symlink(address, new_link_address);
rename(new_link_address, link_address);
free(new_link_address);
}
umask (mask);
free(address);
/* Bind to a TCP socket */
} else {
listener = socket(AF_INET, SOCK_STREAM, 0);
if (listener == -1) {
LOG(LOG_CRIT, ERR_DAEMON_SOCKET, strerror(errno));
return(EFAILURE);
}
if (setsockopt(listener,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
close(listener);
LOG(LOG_CRIT, ERR_DAEMON_SOCKOPT, "SO_REUSEADDR", strerror(errno));
return(EFAILURE);
}
memset(&local_addr, 0, sizeof(struct sockaddr_in));
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(port);
local_addr.sin_addr.s_addr = INADDR_ANY;
LOGDEBUG(INFO_DAEMON_BIND, port);
if (bind(listener, (struct sockaddr *)&local_addr,
sizeof(struct sockaddr)) == -1)
{
close(listener);
LOG(LOG_CRIT, ERR_DAEMON_BIND, port, strerror(errno));
return(EFAILURE);
}
}
/* Listen */
if (listen(listener, queue) == -1) {
close(listener);
LOG(LOG_CRIT, ERR_DAEMON_LISTEN, strerror(errno));
return(EFAILURE);
}
FD_SET(listener, &master);
fdmax = listener;
/* Process new connections (until death or reload) */
for(;;) {
read_fds = master;
tv.tv_sec = 2;
tv.tv_usec = 0;
if (__daemon_run == 0) {
close(listener);
char* address = _ds_read_attribute(agent_config, "ServerDomainSocketPath");
if (address) {
if (_ds_match_attribute(agent_config, "ServerDomainSymlink", "on")) {
/* unlink the actual domain socket */
char* real_address = malloc(sizeof(char) * (strlen(address) + 8));
sprintf(real_address, "%s.%d", address, getpid());
unlink (real_address);
/* remove the symlink only if we still own it */
char link_target[256];
int ret = readlink(address, link_target, sizeof(link_target)-1);
if (ret >= 0) {
/* readlink doesn't null-terminate */
link_target[ret] = '\0';
if (!strcmp(link_target, real_address)) {
unlink (address);
}
}
free(real_address);
}
else
unlink (address);
}
return 0;
}
if (select(fdmax+1, &read_fds, NULL, NULL, &tv)>0) {
/* Process read-ready connections */
for(i=0;i<=fdmax;i++) {
if (FD_ISSET(i, &read_fds)) {
/* Accept new connections */
if (i == listener) {
int newfd;
int addrlen = sizeof(remote_addr);
if ((newfd = accept(listener,
(struct sockaddr *)&remote_addr,
(socklen_t *) &addrlen)) == -1)
{
LOG(LOG_WARNING, ERR_DAEMON_ACCEPT, strerror(errno));
continue;
#ifdef DEBUG
} else if (!domain) {
char buff[32];
LOGDEBUG("connection id %d from %s.", newfd,
inet_ntoa_r(remote_addr.sin_addr, buff, sizeof(buff)));
#endif
}
fcntl(newfd, F_SETFL, O_RDWR);
setsockopt(newfd,SOL_SOCKET,TCP_NODELAY,&yes,sizeof(int));
/*
* Since processing time varies, each new connection gets its own
* thread, so we create a new thread context and send it on its way
*
*/
TTX = calloc(1, sizeof(THREAD_CTX));
if (TTX == NULL) {
LOG(LOG_CRIT, ERR_MEM_ALLOC);
close(newfd);
continue;
} else {
TTX->sockfd = newfd;
TTX->DTX = DTX;
memcpy(&TTX->remote_addr, &remote_addr, sizeof(remote_addr));
increment_thread_count();
if (pthread_create(&TTX->thread,
&attr, process_connection, (void *) TTX))
{
decrement_thread_count();
LOG(LOG_CRIT, ERR_DAEMON_THREAD, strerror(errno));
close(TTX->sockfd);
free(TTX);
continue;
}
}
} /* if i == listener */
} /* if FD_SET else */
} /* for(i.. */
} /* if (select)... */
} /* for(;;) */
/* Shutdown - we should never get here, but who knows */
close(listener);
pthread_attr_destroy(&attr);
return 0;
}
static void _print(gpointer key, gpointer value, gpointer userdata) {
LOGDEBUG(" * key: %s, value: %s", (char *) key, (char *) value);
}
LONG W32DialogFunc(HWND hdlg, UINT uMsg, DWORD uParam, LPARAM lParam)
{
BOOL fSuccess;
register PWW pww;
WM32MSGPARAMEX wm32mpex;
BOOL fMessageNeedsThunking;
#ifdef WOWPROFILE // for MSG profiling only (debugger extension)
extern INT fWMsgProfRT;
DWORD dwTics;
#endif // WOWPROFILE
// If the app has GP Faulted we don't want to pass it any more input
// This should be removed when USER32 does clean up on task death so
// it doesn't call us - mattfe june 24 92
if (CURRENTPTD()->dwFlags & TDF_IGNOREINPUT) {
LOGDEBUG(6,(" W32DialogFunc Ignoring Input Messsage %04X\n",uMsg));
WOW32ASSERTMSG(!gfIgnoreInputAssertGiven,
"WCD32CommonDialogProc: TDF_IGNOREINPUT hack was used, shouldn't be, "
"please email DaveHart with repro instructions. Hit 'g' to ignore this "
"and suppress this assertion from now on.\n");
gfIgnoreInputAssertGiven = TRUE;
goto SilentError;
}
if (!(pww = (PWW) GetWindowLong(hdlg, GWL_WOWWORDS))) {
LOGDEBUG(LOG_ALWAYS,(" W32DialogFunc ERROR: cannot find alias for window %08lx\n", hdlg));
goto Error;
}
// If pww->vpfnDlgProc is NULL, then something is broken; we
// certainly can't continue because we don't know what 16-bit func to call
if (!pww->vpfnDlgProc) {
LOGDEBUG(LOG_ALWAYS,(" W32DialogFunc ERROR: no window proc for message %04x Dlg = %08lx\n", uMsg, hdlg ));
goto Error;
}
wm32mpex.Parm16.WndProc.hwnd = GETHWND16(hdlg);
wm32mpex.Parm16.WndProc.wMsg = (WORD)uMsg;
wm32mpex.Parm16.WndProc.wParam = (WORD)uParam;
wm32mpex.Parm16.WndProc.lParam = (LONG)lParam;
wm32mpex.Parm16.WndProc.hInst = 0; // Forces AX = SS on WndProc entry,
// for Win 3.1 compatibility.
fMessageNeedsThunking = (uMsg < 0x400) &&
(aw32Msg[uMsg].lpfnM32 != WM32NoThunking);
if (fMessageNeedsThunking) {
LOGDEBUG(3,("%04X (%s)\n", CURRENTPTD()->htask16, (aw32Msg[uMsg].lpszW32)));
#ifdef WOWPROFILE // for MSG profiling only (debugger extension)
dwTics = GetWOWTicDiff(0L);
#endif // WOWPROFILE
wm32mpex.fThunk = THUNKMSG;
wm32mpex.hwnd = hdlg;
wm32mpex.uMsg = uMsg;
wm32mpex.uParam = uParam;
wm32mpex.lParam = lParam;
wm32mpex.pww = pww;
wm32mpex.lpfnM32 = aw32Msg[uMsg].lpfnM32;
if (!(wm32mpex.lpfnM32)(&wm32mpex)) {
LOGDEBUG(LOG_ERROR,(" W32DialogFunc ERROR: cannot thunk 32-bit message %04x\n", uMsg));
goto Error;
}
#ifdef WOWPROFILE // for MSG profiling only (debugger extension)
if( !fWMsgProfRT ) { // only if not round trip profiling
aw32Msg[uMsg].cTics += GetWOWTicDiff(dwTics);
}
#endif // WOWPROFILE
}
else {
LOGDEBUG(6,(" No Thunking was required for the 32-bit message %s(%04x)\n", (LPSZ)GetWMMsgName(uMsg), uMsg));
}
BlockWOWIdle(FALSE);
fSuccess = CallBack16(RET_WNDPROC, &wm32mpex.Parm16, pww->vpfnDlgProc, (PVPVOID)&wm32mpex.lReturn);
BlockWOWIdle(TRUE);
// the callback function of a dialog is of type FARPROC whose return value
// is of type 'int'. Since dx:ax is copied into lReturn in the above
// CallBack16 call, we need to zero out the hiword, otherwise we will be
// returning an erroneous value.
wm32mpex.lReturn = (LONG)((SHORT)(LOWORD(wm32mpex.lReturn)));
if (fMessageNeedsThunking) {
#ifdef WOWPROFILE // for MSG profiling only (debugger extension)
if( !fWMsgProfRT ) { // only if not round trip profiling
dwTics = GetWOWTicDiff(0L);
}
#endif // WOWPROFILE
//
// if you send a message to a dialog what gets returned
// to the caller is the dlg's msgresult window long.
// app dialog functions will call
// SetWindowLong(hdlg, DWL_MSGRESULT, n);
// during message processing so the right thing gets returned.
// scottlu says we only need to do this for wm_gettext, it's
// the only message whose result is an output count.
//
if (uMsg == WM_GETTEXT && wm32mpex.lReturn != 0) {
wm32mpex.lReturn = GetWindowLong(hdlg, DWL_MSGRESULT);
}
wm32mpex.fThunk = UNTHUNKMSG;
(wm32mpex.lpfnM32)(&wm32mpex);
#ifdef WOWPROFILE // for MSG profiling only (debugger extension)
aw32Msg[uMsg].cTics += GetWOWTicDiff(dwTics);
aw32Msg[uMsg].cCalls++; // increment # times message passed
#endif // WOWPROFILE
}
if (!fSuccess)
goto Error;
Done:
return wm32mpex.lReturn;
Error:
LOGDEBUG(6,(" W32DialogFunc WARNING: cannot call back, using default message handling\n"));
SilentError:
wm32mpex.lReturn = 0;
goto Done;
}
void *process_connection(void *ptr) {
char *server_ident = _ds_read_attribute(agent_config, "ServerIdent");
THREAD_CTX *TTX = (THREAD_CTX *) ptr;
AGENT_CTX *ATX = NULL;
char *input, *cmdline = NULL, *token, *ptrptr;
buffer *message = NULL;
char *parms=NULL, *p=NULL;
int i, locked = -1, invalid = 0;
int server_mode = SSM_DSPAM;
char *argv[64];
char buf[1024];
int tries = 0;
int argc = 0;
FILE *fd = 0;
if (_ds_read_attribute(agent_config, "ServerMode") &&
!strcasecmp(_ds_read_attribute(agent_config, "ServerMode"), "standard"))
{
server_mode = SSM_STANDARD;
}
if (_ds_read_attribute(agent_config, "ServerMode") &&
!strcasecmp(_ds_read_attribute(agent_config, "ServerMode"), "auto"))
{
server_mode = SSM_AUTO;
}
/* Initialize a file descriptor hook for dspam to use as stdout */
fd = fdopen(TTX->sockfd, "w");
if (!fd) {
close(TTX->sockfd);
goto CLOSE;
}
setbuf(fd, NULL);
TTX->packet_buffer = buffer_create(NULL);
if (TTX->packet_buffer == NULL)
goto CLOSE;
/*
* Send greeting banner
* in auto mode, we want to look like a regular LMTP server so we don't
* cause any compatibility problems. in dspam mode, we can change this.
*/
snprintf(buf, sizeof(buf), "%d DSPAM %sLMTP %s %s",
LMTP_GREETING,
(server_mode == SSM_DSPAM) ? "D" : "",
VERSION,
(server_mode == SSM_DSPAM) ? "Authentication Required" : "Ready");
if (send_socket(TTX, buf)<=0)
goto CLOSE;
TTX->authenticated = 0;
/* LHLO */
input = daemon_expect(TTX, "LHLO");
if (input == NULL)
goto CLOSE;
if (server_mode == SSM_AUTO && input[4]) {
char buff[128];
/*
* Auto-detect the server mode based on whether or not the ident is
* assigned a password in dspam.conf
*/
snprintf(buff, sizeof(buff), "ServerPass.%s", input + 5);
chomp(buff);
if (_ds_read_attribute(agent_config, buff))
server_mode = SSM_DSPAM;
else
server_mode = SSM_STANDARD;
}
free(input);
/* Advertise extensions */
if (daemon_extension(TTX, (server_ident) ? server_ident :
"localhost.localdomain")<=0)
goto CLOSE;
if (daemon_extension(TTX, "PIPELINING")<=0)
goto CLOSE;
if (daemon_extension(TTX, "ENHANCEDSTATUSCODES")<=0)
goto CLOSE;
if (server_mode == SSM_DSPAM)
if (daemon_extension(TTX, "DSPAMPROCESSMODE")<=0)
goto CLOSE;
if (daemon_reply(TTX, LMTP_OK, "", "SIZE")<=0)
goto CLOSE;
/* Main protocol loop */
while(1) {
char processmode[256];
parms = NULL;
/* Configure a new agent context for each pass */
ATX = calloc(1, sizeof(AGENT_CTX));
if (ATX == NULL) {
LOG(LOG_CRIT, ERR_MEM_ALLOC);
daemon_reply(TTX, LMTP_TEMP_FAIL, "4.3.0", ERR_MEM_ALLOC);
goto CLOSE;
}
if (initialize_atx(ATX)) {
LOG(LOG_ERR, ERR_AGENT_INIT_ATX);
daemon_reply(TTX, LMTP_BAD_CMD, "5.3.0", ERR_AGENT_INIT_ATX);
goto CLOSE;
}
/* MAIL FROM (and authentication, if SSM_DSPAM) */
processmode[0] = 0;
while(!TTX->authenticated) {
input = daemon_expect(TTX, "MAIL FROM");
if (RSET(input))
goto RSET;
if (input == NULL)
goto CLOSE;
else {
char *pass, *ident;
chomp(input);
if (server_mode == SSM_STANDARD) {
TTX->authenticated = 1;
ATX->mailfrom[0] = 0;
_ds_extract_address(ATX->mailfrom, input, sizeof(ATX->mailfrom));
if (daemon_reply(TTX, LMTP_OK, "2.1.0", "OK")<=0) {
free(input);
goto CLOSE;
}
} else {
char id[256];
pass = ident = NULL;
id[0] = 0;
if (!_ds_extract_address(id, input, sizeof(id))) {
pass = strtok_r(id, "@", &ptrptr);
ident = strtok_r(NULL, "@", &ptrptr);
}
if (pass && ident) {
char *serverpass;
char *ptr, *ptr2, *ptr3;
snprintf(buf, sizeof(buf), "ServerPass.%s", ident);
serverpass = _ds_read_attribute(agent_config, buf);
snprintf(buf, sizeof(buf), "ServerPass.%s", ident);
if (serverpass && !strcmp(pass, serverpass)) {
TTX->authenticated = 1;
/* Parse PROCESSMODE service tag */
ptr = strstr(input, "DSPAMPROCESSMODE=\"");
if (ptr) {
char *mode;
int i;
ptr2 = strchr(ptr, '"')+1;
mode = ptr2;
while((ptr3 = strstr(ptr2, "\\\"")))
ptr2 = ptr3+2;
ptr3 = strchr(ptr2+2, '"');
if (ptr3)
ptr3[0] = 0;
strlcpy(processmode, mode, sizeof(processmode));
ptr = processmode;
for(i=0;ptr[i];i++) {
if (ptr[i] == '\\' && ptr[i+1] == '"') {
strcpy(ptr+i, ptr+i+1);
}
}
LOGDEBUG("process mode: '%s'", processmode);
}
if (daemon_reply(TTX, LMTP_OK, "2.1.0", "OK")<=0) {
free(input);
goto CLOSE;
}
}
}
}
free(input);
if (!TTX->authenticated) {
LOGDEBUG("fd %d authentication failure.", TTX->sockfd);
if (daemon_reply(TTX, LMTP_AUTH_ERROR, "5.1.0",
"Authentication Required")<=0)
{
free(input);
goto CLOSE;
}
tries++;
if (tries>=3) {
struct timeval tv;
tv.tv_sec = 5;
tv.tv_usec = 0;
select(0, NULL, NULL, NULL, &tv);
goto CLOSE;
}
}
}
}
/* MAIL FROM response */
snprintf(buf, sizeof(buf), "%d OK", LMTP_OK);
argc = 1;
argv[0] = "dspam";
argv[1] = 0;
/* Load open-LMTP configuration parameters */
if (server_mode == SSM_STANDARD) {
parms = _ds_read_attribute(agent_config, "ServerParameters");
if (parms) {
p = strdup(parms);
if (p) {
token = strtok_r(p, " ", &ptrptr);
while(token != NULL && argc<63) {
argv[argc] = token;
argc++;
argv[argc] = 0;
token = strtok_r(NULL, " ", &ptrptr);
}
}
}
}
/* RCPT TO */
while(ATX->users->items == 0 || invalid) {
free(cmdline);
cmdline = daemon_getline(TTX, 300);
while(cmdline &&
(!strncasecmp(cmdline, "RCPT TO:", 8) ||
!strncasecmp(cmdline, "RSET", 4)))
{
char username[256];
if (!strncasecmp(cmdline, "RSET", 4)) {
snprintf(buf, sizeof(buf), "%d OK", LMTP_OK);
if (send_socket(TTX, buf)<=0)
goto CLOSE;
goto RSET;
}
if (_ds_extract_address(username, cmdline, sizeof(username)) ||
username[0] == 0 || username[0] == '-')
{
daemon_reply(TTX, LMTP_BAD_CMD, "5.1.2", ERR_LMTP_BAD_RCPT);
goto GETCMD;
}
if (_ds_match_attribute(agent_config, "Broken", "case"))
lc(username, username);
if (server_mode == SSM_DSPAM) {
nt_add(ATX->users, username);
}
else {
if (!parms || !strstr(parms, "--user "))
nt_add(ATX->users, username);
if (!ATX->recipients) {
ATX->recipients = nt_create(NT_CHAR);
if (ATX->recipients == NULL) {
LOG(LOG_CRIT, ERR_MEM_ALLOC);
goto CLOSE;
}
}
nt_add(ATX->recipients, username);
}
if (daemon_reply(TTX, LMTP_OK, "2.1.5", "OK")<=0)
goto CLOSE;
GETCMD:
free(cmdline);
cmdline = daemon_getline(TTX, 300);
}
if (cmdline == NULL)
goto CLOSE;
if (!strncasecmp(cmdline, "RSET", 4)) {
snprintf(buf, sizeof(buf), "%d OK", LMTP_OK);
if (send_socket(TTX, buf)<=0)
goto CLOSE;
goto RSET;
}
if (!strncasecmp(cmdline, "quit", 4)) {
daemon_reply(TTX, LMTP_OK, "2.0.0", "OK");
goto CLOSE;
}
/* Parse DSPAMPROCESSMODE input and set up process arguments */
if (server_mode == SSM_DSPAM && processmode[0] != 0) {
token = strtok_r(processmode, " ", &ptrptr);
while(token != NULL && argc<63) {
argv[argc] = token;
argc++;
argv[argc] = 0;
token = strtok_r(NULL, " ", &ptrptr);
}
}
invalid = 0;
if (process_arguments(ATX, argc, argv) || apply_defaults(ATX))
{
LOG(LOG_ERR, ERR_AGENT_INIT_ATX);
daemon_reply(TTX, LMTP_NO_RCPT, "5.1.0", ERR_AGENT_INIT_ATX);
invalid = 1;
} else if (ATX->users->items == 0) {
daemon_reply(TTX, LMTP_NO_RCPT, "5.1.1", ERR_AGENT_USER_UNDEFINED);
}
}
ATX->sockfd = fd;
ATX->sockfd_output = 0;
/* Something's terribly misconfigured */
if (check_configuration(ATX)) {
LOG(LOG_ERR, ERR_AGENT_MISCONFIGURED);
daemon_reply(TTX, LMTP_BAD_CMD, "5.3.5", ERR_AGENT_MISCONFIGURED);
goto CLOSE;
}
/* DATA */
if (strncasecmp(cmdline, "DATA", 4)) {
if (daemon_reply(TTX, LMTP_BAD_CMD, "5.0.0", "Need DATA Here")<0)
goto CLOSE;
input = daemon_expect(TTX, "DATA");
if (input == NULL)
goto CLOSE;
if (RSET(input))
goto RSET;
}
if (daemon_reply(TTX, LMTP_DATA, "", INFO_LMTP_DATA)<=0)
goto CLOSE;
/*
* Read in the message from a DATA. I personally like to just hang up on
* a client stupid enough to pass in a NULL message for DATA, but you're
* welcome to do whatever you want.
*/
message = read_sock(TTX, ATX);
if (message == NULL || message->data == NULL || message->used == 0) {
daemon_reply(TTX, LMTP_FAILURE, "5.2.0", ERR_LMTP_MSG_NULL);
goto CLOSE;
}
/*
* Lock a database handle. We currently use the modulus of the socket
* id against the number of database connections in the cache. This
* seems to work rather well, as we would need to lock up the entire
* cache to wrap back around. And if we do wrap back around, that means
* we're busy enough to justify spinning on the current lock (vs. seeking
* out a free handle, which there likely are none).
*/
i = (TTX->sockfd % TTX->DTX->connection_cache);
LOGDEBUG("using database handle id %d", i);
if (TTX->DTX->flags & DRF_RWLOCK) {
if (ATX->operating_mode == DSM_CLASSIFY ||
ATX->training_mode == DST_NOTRAIN ||
(ATX->training_mode == DST_TOE && ATX->classification == DSR_NONE))
{
pthread_rwlock_rdlock(&TTX->DTX->connections[i]->rwlock);
} else {
pthread_rwlock_wrlock(&TTX->DTX->connections[i]->rwlock);
}
} else {
pthread_mutex_lock(&TTX->DTX->connections[i]->lock);
}
LOGDEBUG("handle locked");
ATX->dbh = TTX->DTX->connections[i]->dbh;
locked = i;
/* Process the message by tying back into the agent functions */
ATX->results = nt_create(NT_PTR);
if (ATX->results == NULL) {
LOG(LOG_CRIT, ERR_MEM_ALLOC);
goto CLOSE;
}
process_users(ATX, message);
/*
* Unlock the database handle as soon as we're done. We also need to
* refresh our handle index with a new handle if for some reason we
* had to re-establish a dewedged connection.
*/
if (TTX->DTX->connections[locked]->dbh != ATX->dbh)
TTX->DTX->connections[locked]->dbh = ATX->dbh;
if (TTX->DTX->flags & DRF_RWLOCK) {
pthread_rwlock_unlock(&TTX->DTX->connections[locked]->rwlock);
} else {
pthread_mutex_unlock(&TTX->DTX->connections[locked]->lock);
}
locked = -1;
/* Send a terminating '.' if --stdout in 'dspam' mode */
if (ATX->sockfd_output) {
if (!(ATX->flags & DAF_SUMMARY))
if (send_socket(TTX, ".")<=0)
goto CLOSE;
/* Otherwise, produce standard delivery results */
} else {
struct nt_node *node_nt, *node_res = NULL;
struct nt_c c_nt;
if (ATX->recipients)
node_nt = c_nt_first(ATX->recipients, &c_nt);
else
node_nt = c_nt_first(ATX->users, &c_nt);
if (ATX->results)
node_res = ATX->results->first;
while(node_res && node_nt != NULL) {
agent_result_t result = (agent_result_t) node_res->ptr;
if (result != NULL && result->exitcode == ERC_SUCCESS)
{
if (server_mode == SSM_DSPAM) {
snprintf(buf, sizeof(buf),
"%d 2.6.0 <%s> Message accepted for delivery: %s",
LMTP_OK, (char *) node_nt->ptr,
(result->classification == DSR_ISSPAM) ? "SPAM" : "INNOCENT");
} else {
snprintf(buf, sizeof(buf),
"%d 2.6.0 <%s> Message accepted for delivery",
LMTP_OK, (char *) node_nt->ptr);
}
}
else
{
if (result->exitcode == ERC_PERMANENT_DELIVERY) {
snprintf(buf, sizeof(buf), "%d 5.3.0 <%s> %s",
LMTP_FAILURE, (char *) node_nt->ptr,
(result->text[0]) ? result->text : "Permanent error occured");
} else {
if (result->text[0]) {
snprintf(buf, sizeof(buf),
"%d 4.3.0 <%s> %s",
LMTP_TEMP_FAIL, (char *) node_nt->ptr, result->text);
} else {
snprintf(buf, sizeof(buf),
"%d 4.3.0 <%s> Error occured during %s",
LMTP_TEMP_FAIL, (char *) node_nt->ptr,
(result->exitcode == ERC_DELIVERY) ? "delivery" : "processing");
}
}
}
if (send_socket(TTX, buf)<=0)
goto CLOSE;
if (ATX->recipients)
node_nt = c_nt_next(ATX->recipients, &c_nt);
else
node_nt = c_nt_next(ATX->users, &c_nt);
if (node_res)
node_res = node_res->next;
}
}
/* Cleanup and get ready for another message */
RSET:
fflush(fd);
buffer_destroy(message);
message = NULL;
if (ATX != NULL) {
nt_destroy(ATX->users);
nt_destroy(ATX->recipients);
nt_destroy(ATX->results);
free(ATX);
ATX = NULL;
free(cmdline);
cmdline = NULL;
TTX->authenticated = 0;
argc = 0;
}
free(p);
p = NULL;
} /* while(1) */
/* Close connection and return */
CLOSE:
if (locked>=0)
pthread_mutex_unlock(&TTX->DTX->connections[locked]->lock);
if (fd)
fclose(fd);
buffer_destroy(TTX->packet_buffer);
if (message)
buffer_destroy(message);
if (ATX != NULL) {
nt_destroy(ATX->users);
nt_destroy(ATX->recipients);
nt_destroy(ATX->results);
}
free(ATX);
free(cmdline);
free(TTX);
decrement_thread_count();
pthread_exit(0);
return 0;
}
int serialport_open(const char *device, unsigned int baudrate)
{
LOGINFO("opening port %s at %d", device, baudrate);
int flags = O_RDWR | O_NOCTTY;
#ifdef __APPLE__
flags |= O_NONBLOCK;
#endif
serial_port = open(device, flags);
if(serial_port<0)
{
LOGERR("cannot access %s\n",device);
return 0;
}
#ifdef __APPLE__
flags = fcntl(serial_port, F_GETFL, 0);
fcntl(serial_port, F_SETFL, flags & (~O_NONBLOCK));
#endif
serialport_set_dtr(0);
LOGDEBUG("tcgetattr");
tcgetattr(serial_port,&term);
serialport_set_baudrate(baudrate);
term.c_cflag = (term.c_cflag & ~CSIZE) | CS8;
term.c_cflag |= CLOCAL | CREAD;
term.c_cflag &= ~(PARENB | PARODD);
term.c_cflag &= ~CSTOPB;
term.c_iflag = IGNBRK;
term.c_iflag &= ~(IXON | IXOFF);
term.c_lflag = 0;
term.c_oflag = 0;
term.c_cc[VMIN]=0;
term.c_cc[VTIME]=1;
timeout = 100;
LOGDEBUG("tcsetattr");
if (tcsetattr(serial_port, TCSANOW, &term)!=0)
{
LOGERR("setattr stage 1 failed");
return 0;
}
if (tcgetattr(serial_port, &term)!=0)
{
LOGERR("getattr failed");
return 0;
}
term.c_cflag &= ~CRTSCTS;
if (tcsetattr(serial_port, TCSANOW, &term)!=0)
{
LOGERR("setattr stage 2 failed");
return 0;
}
LOGDEBUG("serial open");
return serial_port;
}
size_t ApiHook::CreateReroute(LPBYTE &hookInsertionAddress)
{
size_t size = 0;
size_t relativeAdd = 0;
int num = 0;
PBYTE curPos = _fdisasm.GetEnd();
Disasm disasm = _fdisasm.GetDisasm();
// Calculate how many instructions need to be moved
PBYTE preHookJumpTarget = NULL;
while (size < sizeof(jump)) {
if ((size == 0) && (disasm.GetOpcode() == 0xE9)) {
LOGDEBUG("%s seems to be hooked already: %ls",
_functionName, ::GetSectionName(disasm.GetAbsoluteDestination()).c_str());
preHookJumpTarget = disasm.GetAbsoluteDestination();
} else if ((size == 0) && (disasm.GetOpcode() == 0xEB)) {
// short jump, may be a hot-patch
PBYTE pos = disasm.GetAbsoluteDestination();
Disasm refDisasm(pos);
if (refDisasm.GetOpcode() == 0xE9) {
// aha, it IS a hot patch
LOGDEBUG("%s seems to be hooked already (hot-patch): %ls",
_functionName, ::GetSectionName(refDisasm.GetAbsoluteDestination()).c_str());
hookInsertionAddress = pos;
preHookJumpTarget = refDisasm.GetAbsoluteDestination();
}
}
if (disasm.IsRelative()) {
relativeAdd += 3 + sizeof(void*); // if the jump is relative or near, it will have to
// be adjusted, possible increasing the size of the command
}
size += disasm.GetSize();
num++;
curPos = disasm.GetNextCommand();
}
if (preHookJumpTarget == NULL) {
int tmpnum = num;
size_t tmpsize = size;
// Continue copying operations if a jump follows that targets the already to-be-copied area
while (curPos < _fdisasm.GetEnd()) {
tmpnum++;
tmpsize += disasm.GetSize();
if (disasm.JumpTargets(hookInsertionAddress, hookInsertionAddress + size)) {
num = tmpnum;
size = tmpsize;
}
curPos = disasm.GetNextCommand();
}
} // no need to fix jumps
size_t jlen = sizeof(void*) + 1; // size of a jump: 1 byte opcode + size of an address
// allocate memory for the reroute that is executable
_reroute = reinterpret_cast<LPBYTE>(::VirtualAlloc(nullptr,
size + jlen + sizeof(char*) + relativeAdd,
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE));
LPBYTE rerouteEnd = _reroute;
if (preHookJumpTarget == NULL) {
disasm.Reset();
// Copy instructions and adjust relative jumps if neccessary
for (int i = 0; i < num; i++) {
rerouteEnd = disasm.CopyTo(rerouteEnd, hookInsertionAddress, size);
disasm.GetNextCommand();
}
} // no need to copy instructions
// Add jump back to original function or the next hook in the chain
*rerouteEnd = 0xE9; // JMP
++rerouteEnd;
if (preHookJumpTarget == NULL) {
*(reinterpret_cast<ULONG*>(rerouteEnd)) =
reinterpret_cast<ULONG>(hookInsertionAddress) + size -
(reinterpret_cast<ULONG>(rerouteEnd) + sizeof(ULONG)); // Distance to original function
} else {
*(reinterpret_cast<ULONG*>(rerouteEnd)) =
reinterpret_cast<ULONG>(preHookJumpTarget) -
(reinterpret_cast<ULONG>(rerouteEnd) + sizeof(ULONG)); // Distance to original function
}
return size;
}
//!
//!
//!
//! @param[in] inst a pointer to the instance structure
//! @param[in] in a transparent pointer (unused)
//!
//! @return
//!
//! @pre
//!
//! @note
//!
int instNetParamsSet(ccInstance * inst, void *in)
{
int rc = 0;
int ret = 0;
char userToken[64] = { 0 };
char *cleanGroupName = NULL;
if (!inst) {
return (1);
} else if ((strcmp(inst->state, "Pending") && strcmp(inst->state, "Extant"))) {
return (0);
}
LOGDEBUG("instanceId=%s publicIp=%s privateIp=%s privateMac=%s vlan=%d\n", inst->instanceId, inst->ccnet.publicIp,
inst->ccnet.privateIp, inst->ccnet.privateMac, inst->ccnet.vlan);
if (inst->ccnet.vlan >= 0) {
// activate network
vnetconfig->networks[inst->ccnet.vlan].active = 1;
// set up groupName and userName
if (inst->groupNames[0][0] != '\0' && inst->accountId[0] != '\0') {
// logic to strip the username from the supplied network name
snprintf(userToken, 63, "%s-", inst->accountId);
cleanGroupName = strstr(inst->groupNames[0], userToken);
if (cleanGroupName) {
cleanGroupName = cleanGroupName + strlen(userToken);
} else {
cleanGroupName = inst->groupNames[0];
}
// if ( (vnetconfig->users[inst->ccnet.vlan].netName[0] != '\0' && strcmp(vnetconfig->users[inst->ccnet.vlan].netName, inst->groupNames[0])) || (vnetconfig->users[inst->ccnet.vlan].userName[0] != '\0' && strcmp(vnetconfig->users[inst->ccnet.vlan].userName, inst->accountId)) ) {
if ((vnetconfig->users[inst->ccnet.vlan].netName[0] != '\0' && strcmp(vnetconfig->users[inst->ccnet.vlan].netName, cleanGroupName))
|| (vnetconfig->users[inst->ccnet.vlan].userName[0] != '\0' && strcmp(vnetconfig->users[inst->ccnet.vlan].userName, inst->accountId))) {
// this means that there is a pre-existing network with the passed in vlan tag, but with a different netName or userName
LOGERROR("input instance vlan<->user<->netname mapping is incompatible with internal state. Internal - userName=%s netName=%s "
"vlan=%d. Instance - userName=%s netName=%s vlan=%d\n", vnetconfig->users[inst->ccnet.vlan].userName,
vnetconfig->users[inst->ccnet.vlan].netName, inst->ccnet.vlan, inst->accountId, cleanGroupName, inst->ccnet.vlan);
ret = 1;
} else {
// snprintf(vnetconfig->users[inst->ccnet.vlan].netName, 32, "%s", inst->groupNames[0]);
snprintf(vnetconfig->users[inst->ccnet.vlan].netName, 64, "%s", cleanGroupName);
snprintf(vnetconfig->users[inst->ccnet.vlan].userName, 48, "%s", inst->accountId);
}
}
}
if (!ret) {
// so far so good
rc = vnetGenerateNetworkParams(vnetconfig, inst->instanceId, inst->ccnet.vlan, inst->ccnet.networkIndex, inst->ccnet.privateMac,
inst->ccnet.publicIp, inst->ccnet.privateIp);
if (rc) {
print_ccInstance("failed to (re)generate network parameters: ", inst);
ret = 1;
}
}
if (ret) {
LOGDEBUG("sync of network cache with instance data FAILED (instanceId=%s, publicIp=%s, privateIp=%s, vlan=%d, networkIndex=%d\n",
inst->instanceId, inst->ccnet.publicIp, inst->ccnet.privateIp, inst->ccnet.vlan, inst->ccnet.networkIndex);
} else {
LOGDEBUG("sync of network cache with instance data SUCCESS (instanceId=%s, publicIp=%s, privateIp=%s, vlan=%d, networkIndex=%d\n",
inst->instanceId, inst->ccnet.publicIp, inst->ccnet.privateIp, inst->ccnet.vlan, inst->ccnet.networkIndex);
}
return (0);
}
int _ds_tokenize_ngram(
DSPAM_CTX *CTX,
char *headers,
char *body,
ds_diction_t diction)
{
char *token; /* current token */
char *previous_token = NULL; /* used for bigrams (chained tokens) */
char *line = NULL; /* header broken up into lines */
char *ptrptr;
char heading[128]; /* current heading */
int l, tokenizer = CTX->tokenizer;
struct nt *header = NULL;
struct nt_node *node_nt;
struct nt_c c_nt;
/* Tokenize URLs in message */
if (_ds_match_attribute(CTX->config->attributes, "ProcessorURLContext", "on")) {
_ds_url_tokenize(diction, body, "http://");
_ds_url_tokenize(diction, body, "www.");
_ds_url_tokenize(diction, body, "href=");
}
/*
* Header Tokenization
*/
header = nt_create (NT_CHAR);
if (header == NULL)
{
LOG (LOG_CRIT, ERR_MEM_ALLOC);
return EUNKNOWN;
}
line = strtok_r (headers, "\n", &ptrptr);
while (line) {
nt_add (header, line);
line = strtok_r (NULL, "\n", &ptrptr);
}
node_nt = c_nt_first (header, &c_nt);
heading[0] = 0;
while (node_nt) {
int multiline;
#ifdef VERBOSE
LOGDEBUG("processing line: %s", node_nt->ptr);
#endif
line = static_cast<char *>(node_nt->ptr);
token = strtok_r (line, ":", &ptrptr);
if (token && token[0] != 32 && token[0] != 9 && !strstr (token, " "))
{
multiline = 0;
strlcpy (heading, token, 128);
previous_token = NULL;
} else {
multiline = 1;
}
#ifdef VERBOSE
LOGDEBUG ("Reading '%s' header from: '%s'", heading, line);
#endif
if (CTX->flags & DSF_WHITELIST) {
/* Use the entire From: line for auto-whitelisting */
if (!strcmp(heading, "From")) {
char wl[256];
char *fromline = line + 5;
unsigned long long whitelist_token;
if (fromline[0] == 32)
fromline++;
snprintf(wl, sizeof(wl), "%s*%s", heading, fromline);
whitelist_token = _ds_getcrc64(wl);
ds_diction_touch(diction, whitelist_token, wl, 0);
diction->whitelist_token = whitelist_token;
}
}
/* Received headers use a different set of delimiters to preserve things
like ip addresses */
token = strtok_r ((multiline) ? line : NULL, DELIMITERS_HEADING, &ptrptr);
while (token)
{
l = strlen(token);
if (l >= 1 && l < 50)
{
#ifdef VERBOSE
LOGDEBUG ("Processing '%s' token in '%s' header", token, heading);
#endif
/* Process "current" token */
if (!_ds_process_header_token
(CTX, token, previous_token, diction, heading) &&
(tokenizer == DSZ_CHAIN))
{
previous_token = token;
}
}
token = strtok_r (NULL, DELIMITERS_HEADING, &ptrptr);
}
previous_token = NULL;
node_nt = c_nt_next (header, &c_nt);
}
nt_destroy (header);
/*
* Body Tokenization
*/
#ifdef VERBOSE
LOGDEBUG("parsing message body");
#endif
token = strtok_r (body, DELIMITERS, &ptrptr);
while (token != NULL)
{
l = strlen (token);
if (l >= 1 && l < 50)
{
#ifdef VERBOSE
LOGDEBUG ("Processing body token '%s'", token);
#endif
/* Process "current" token */
if ( !_ds_process_body_token(CTX, token, previous_token, diction)
&& tokenizer == DSZ_CHAIN)
{
previous_token = token;
}
}
token = strtok_r (NULL, DELIMITERS, &ptrptr);
}
#ifdef VERBOSE
LOGDEBUG("Finished tokenizing (ngram) message");
#endif
/* Final token reassembly (anything left in the buffer) */
return 0;
}
//!
//! Creates and initialize an NC stub entry
//!
//! @param[in] endpoint_uri the endpoint URI string
//! @param[in] logfile the log file name string
//! @param[in] homedir the home directory path string
//!
//! @return a pointer to the newly created NC stub structure
//!
ncStub *ncStubCreate(char *endpoint_uri, char *logfile, char *homedir)
{
char *uri = NULL;
char *p = NULL;
char *node_name = NULL;
axutil_env_t *env = NULL;
axis2_char_t *client_home = NULL;
axis2_stub_t *stub = NULL;
ncStub *st = NULL;
if (logfile) {
env = axutil_env_create_all(logfile, AXIS2_LOG_LEVEL_TRACE);
} else {
env = axutil_env_create_all(NULL, 0);
}
if (homedir) {
client_home = (axis2_char_t *) homedir;
} else {
client_home = AXIS2_GETENV("AXIS2C_HOME");
}
if (client_home == NULL) {
LOGERROR("fakeNC: ERROR: cannot get AXIS2C_HOME");
return NULL;
}
if (endpoint_uri == NULL) {
LOGERROR("fakeNC: ERROR: empty endpoint_url");
return NULL;
}
uri = endpoint_uri;
// extract node name from the endpoint
p = strstr(uri, "://"); // find "http[s]://..."
if (p == NULL) {
LOGERROR("fakeNC: ncStubCreate received invalid URI %s\n", uri);
return NULL;
}
node_name = strdup(p + 3); // copy without the protocol prefix
if (node_name == NULL) {
LOGERROR("fakeNC: ncStubCreate is out of memory\n");
return NULL;
}
if ((p = strchr(node_name, ':')) != NULL)
*p = '\0'; // cut off the port
if ((p = strchr(node_name, '/')) != NULL)
*p = '\0'; // if there is no port
LOGDEBUG("fakeNC: DEBUG: requested URI %s\n", uri);
// see if we should redirect to a local broker
if (strstr(uri, "EucalyptusBroker")) {
uri = "http://localhost:8773/services/EucalyptusBroker";
LOGDEBUG("fakeNC: DEBUG: redirecting request to %s\n", uri);
}
//! @todo what if endpoint_uri, home, or env are NULL?
stub = axis2_stub_create_EucalyptusNC(env, client_home, (axis2_char_t *) uri);
if (stub && (st = EUCA_ZALLOC(1, sizeof(ncStub)))) {
st->env = env;
st->client_home = strdup((char *)client_home);
st->endpoint_uri = (axis2_char_t *) strdup(endpoint_uri);
st->node_name = (axis2_char_t *) strdup(node_name);
st->stub = stub;
if (st->client_home == NULL || st->endpoint_uri == NULL) {
LOGWARN("fakeNC: WARNING: out of memory");
}
} else {
LOGWARN("fakeNC: WARNING: out of memory");
}
EUCA_FREE(node_name);
return (st);
}
void CConnManager::Execute(Thread::Arg arg)
{
TcpSocket *new_socket;
CConnHandler *cconnhandler;
CConnHandler *new_cconnhandler;
TcpServerSocket* listening_socket=0;
tUInt32 counter=0;
//tSInt64 starttime;
//tSInt64 endtime;
//starttime=Timer::GetAbsoluteTime();
LOGINFO("CConnManager starting up...");
try
{
listening_socket = new TcpServerSocket(_listen_port);
}
catch(SocketException &e)
{
LOGINFO("CConnManager::Execute:Failed to instantiate the listening socket,exception:"<<e.Description()<<".");
if (listening_socket)
{
listening_socket->Disconnect();
delete listening_socket;
}
return;
}
/** Start a pool of permanert handlers.*/
for (tUInt32 i=0;i<_permanent_handler_num;i++)
{
new_cconnhandler = new CConnHandler(this,TRUE,_filelog);
new_cconnhandler->Start();
_handler_vec.push_back(new_cconnhandler);
}
while(!_is_shutdown_requested)
{
//For it's time consuming, we do it once every 250 loops.
counter++;
if (counter==250)
{
counter=0;
CleanShutdownConnections();
}
// Check if there is a new connection request
// Wait and check within 100 milliseconds
if (!listening_socket->IsReadyForRead(100))
{
// No. Then just yield CPU to others
// and retry later.
//LOGDEBUG("CConnManager: not ready for read");
Yield();
continue;
}
try
{
new_socket=listening_socket->Accept();
}
catch(SocketException &e)
{
LOGERROR("CConnManager::Execute:Failed to instanciate socket for new incoming connection:'"<<e.Description()<<"'.");
continue;
}
catch (exception &e)
{
LOGERROR("CConnManager::Execute:Failed to instanciate socket for new incoming connection:'"<<e.what()<<"'.");
continue;
}
LOGDEBUG("CConnManager::Execute:Received a new connection from '"<<new_socket->PeerHostAddress()<<"'.");
new_socket->SetKeepAlive();
cconnhandler = FindMostLeisureHandler();
if (!cconnhandler)
{
new_cconnhandler = new CConnHandler(this,FALSE,_filelog);
new_cconnhandler->Start();
_handler_vec.push_back(new_cconnhandler);
}
else if (cconnhandler->CanContainMore())
cconnhandler->SaveSocket(new_socket);
else
{
if (_handler_vec.size()<_handler_max)
{
new_cconnhandler = new CConnHandler(this,FALSE,_filelog);
new_cconnhandler->Start();
_handler_vec.push_back(new_cconnhandler);
new_cconnhandler->SaveSocket(new_socket);
}
else
cconnhandler->SaveSocket(new_socket); // Ask the handler to forward it to other slave server.
}
} // while(!_is_shutdown_requested)
// Here we received a shutdown signal!
// Then shuting down all current connections.
ShutdownAllConnections();
CleanShutdownConnections();
//endtime=Timer::GetAbsoluteTime();
//Timer::Shutdown();
LOGINFO("CConnManager shutdowned.");
}
//!
//!
//!
//! @param[in] log_error
//! @param[in] format
//! @param[in] ...
//!
//! @return
//!
//! @pre
//!
//! @note
//!
static char *execlp_output(boolean log_error, ...)
{
va_list ap;
int ntokens = 0;
char cmd[256] = ""; // for logging, OK if command gets truncated
// run through arguments once to count them
va_start(ap, log_error);
{
char *s;
while ((s = va_arg(ap, char *)) != NULL) {
ntokens++;
}
}
va_end(ap);
if (ntokens < 1) {
LOGERROR("internal error: too few arguments to %s\n", __func__);
return NULL;
}
// allocate an array and run through arguments again, copying them into the array
char **argv = EUCA_ZALLOC(ntokens + 1, sizeof(char *)); // one extra for the terminating NULL
va_start(ap, log_error);
{
for (int i = 0; i < ntokens; i++) {
argv[i] = strdup(va_arg(ap, char *));
// append tokens to 'cmd', strictly for logging purposes
int left_in_cmd = sizeof(cmd) - strlen(cmd);
if (left_in_cmd > 1) // has room for at least one character and '\0'
snprintf(cmd + strlen(cmd), left_in_cmd, "%s%s%s%s", (i > 0) ? (" ") : (""), // add space in front all but the first argument
(i == 0 || argv[i][0] == '-') ? ("") : ("'"), // add quoates around non-flags
argv[i], (i == 0 || argv[i][0] == '-') ? ("") : ("'"));
}
}
va_end(ap);
char *output = NULL;
// set up a pipe for getting stdout and stderror from child process
int filedes[2];
if (pipe(filedes)) {
LOGERROR("failed to create a pipe\n");
goto free;
}
LOGTRACE("executing: %s\n", cmd);
pid_t cpid = fork();
int rc = -1;
if (cpid == -1) {
LOGERROR("failed to fork\n");
close(filedes[0]);
close(filedes[1]);
goto free;
} else if (cpid == 0) { // child
close(filedes[0]);
if (dup2(filedes[1], STDOUT_FILENO) == -1) {
LOGERROR("failed to dup2\n");
exit(-1);
}
if (dup2(filedes[1], STDERR_FILENO) == -1) {
LOGERROR("failed to dup2\n");
exit(-1);
}
exit(execvp(argv[0], argv));
}
// parent reads stdout and stdin from child into a string
close(filedes[1]);
int outsize = OUTPUT_ALLOC_CHUNK; // allocate in chunks of this size
int nextchar = 0; // offset of the next usable char
int bytesread;
output = EUCA_ALLOC(outsize, sizeof(char));
if (output) {
output[0] = '\0'; // return an empty string if there is no output
}
while ((output != NULL) && (bytesread = read(filedes[0], output + nextchar, outsize - nextchar - 1)) > 0) {
nextchar += bytesread;
output[nextchar] = '\0';
if (nextchar + 1 == outsize) {
outsize += OUTPUT_ALLOC_CHUNK;
if (outsize > MAX_OUTPUT_BYTES) {
LOGERROR("internal error: output from command is too long\n");
EUCA_FREE(output);
break;
}
output = EUCA_REALLOC(output, outsize, sizeof(char));
}
}
if (output == NULL) {
LOGERROR("failed to allocate mem for output\n");
}
close(filedes[0]);
{ // wait for the child to reap status
int status;
rc = waitpid(cpid, &status, 0);
if (rc == -1) {
LOGERROR("failed to wait for child process\n");
} else if (WIFEXITED(status)) {
rc = WEXITSTATUS(status);
if (rc) {
LOGERROR("child return non-zero status (%d)\n", rc);
}
} else {
LOGERROR("child process did not terminate normally\n");
rc = -1;
}
}
if (rc) {
// there were problems above
if ((output != NULL) && strstr(cmd, "losetup") && strstr(output, ": No such device or address")) {
rc = 0;
} else {
if (log_error) {
LOGERROR("bad return code from cmd %s\n", cmd);
LOGDEBUG("%s\n", output);
}
EUCA_FREE(output); // will be set to NULL
}
}
free:
for (int i = 0; i < ntokens; i++) {
EUCA_FREE(argv[i]);
}
EUCA_FREE(argv);
return output;
}
void maincfg_print_to_log(void) {
LOGDEBUG("MainCFG:");
g_hash_table_foreach(Cfg, _print, NULL);
}
//!
//!
//!
//! @param[in] path
//! @param[in] offset
//! @param[in] lodev name of the loop device
//! @param[in] lodev_size
//!
//! @return EUCA_OK on success or the following error codes:
//! \li EUCA_ERROR: if any error occured.
//! \li EUCA_INVALID_ERROR: if any parameter does not meet the preconditions.
//!
//! @pre Both path and lodev parameters must not be NULL.
//!
//! @post On success, the loop device is attached.
//!
int diskutil_loop(const char *path, const long long offset, char *lodev, int lodev_size)
{
int i = 0;
int ret = EUCA_OK;
char *ptr = NULL;
char *output = NULL;
boolean done = FALSE;
boolean found = FALSE;
boolean do_log = FALSE;
if (path && lodev) {
// we retry because we cannot atomically obtain a free loopback device on all distros (some
// versions of 'losetup' allow a file argument with '-f' options, but some do not)
for (i = 0, done = FALSE, found = FALSE; i < LOOP_RETRIES; i++) {
sem_p(loop_sem);
{
output = pruntf(TRUE, "%s %s -f", helpers_path[ROOTWRAP], helpers_path[LOSETUP]);
}
sem_v(loop_sem);
if (output == NULL) {
// there was a problem
break;
}
if (strstr(output, "/dev/loop")) {
strncpy(lodev, output, lodev_size);
if ((ptr = strrchr(lodev, '\n')) != NULL) {
*ptr = '\0';
found = TRUE;
}
}
EUCA_FREE(output);
if (found) {
do_log = ((i + 1) == LOOP_RETRIES); // log error on last try only
LOGDEBUG("attaching file %s\n", path);
LOGDEBUG(" to %s at offset %lld\n", lodev, offset);
sem_p(loop_sem);
{
char str_offset[64];
snprintf(str_offset, sizeof(str_offset), "%lld", offset);
output = execlp_output(do_log, helpers_path[ROOTWRAP], helpers_path[LOSETUP], "-o", str_offset, lodev, path, NULL);
}
sem_v(loop_sem);
if (output == NULL) {
LOGDEBUG("cannot attach to loop device %s (will retry)\n", lodev);
} else {
EUCA_FREE(output);
done = TRUE;
break;
}
}
sleep(1);
found = FALSE;
}
if (!done) {
LOGERROR("cannot find free loop device or attach to one\n");
ret = EUCA_ERROR;
}
return (ret);
}
LOGWARN("cannot attach to loop device. path=%s, lodev=%s\n", SP(path), SP(lodev));
return (EUCA_INVALID_ERROR);
}
//!
//! Function description.
//!
//! @param[in] file
//! @param[in] file_updated
//!
//! @return
//!
//! @see
//!
//! @pre List of pre-conditions
//!
//! @post List of post conditions
//!
//! @note
//!
int atomic_file_get(atomic_file * file, boolean * file_updated)
{
int port = 0;
int fd = 0;
int ret = 0;
int rc = 0;
char *hash = NULL;
char type[32] = "";
char hostname[512] = "";
char path[EUCA_MAX_PATH] = "";
char tmpsource[EUCA_MAX_PATH] = "";
char tmppath[EUCA_MAX_PATH] = "";
if (!file || !file_updated) {
return (1);
}
ret = 0;
*file_updated = FALSE;
snprintf(file->tmpfile, EUCA_MAX_PATH, "%s", file->tmpfilebase);
fd = safe_mkstemp(file->tmpfile);
if (fd < 0) {
LOGERROR("cannot open tmpfile '%s': check permissions\n", file->tmpfile);
return (1);
}
if (chmod(file->tmpfile, 0600)) {
LOGWARN("chmod failed: was able to create tmpfile '%s', but could not change file permissions\n", file->tmpfile);
}
close(fd);
snprintf(tmpsource, EUCA_MAX_PATH, "%s", file->source);
type[0] = tmppath[0] = path[0] = hostname[0] = '\0';
port = 0;
tokenize_uri(tmpsource, type, hostname, &port, tmppath);
snprintf(path, EUCA_MAX_PATH, "/%s", tmppath);
if (!strcmp(type, "http")) {
rc = http_get_timeout(file->source, file->tmpfile, 0, 0, 10, 15, NULL);
if (rc) {
LOGERROR("http client failed to fetch file URL=%s: check http server status\n", file->source);
ret = 1;
}
} else if (!strcmp(type, "file")) {
if (!strlen(path) || copy_file(path, file->tmpfile)) {
LOGERROR("could not copy source file (%s) to dest file (%s): check permissions\n", path, file->tmpfile);
ret = 1;
}
} else {
LOGWARN("BUG: incompatible URI type (%s) passed to routine (only supports http, file)\n", type);
ret = 1;
}
if (!ret) {
if (file->dosort) {
rc = atomic_file_sort_tmpfile(file);
if (rc) {
LOGWARN("could not sort tmpfile (%s) inplace: continuing without sort\n", file->tmpfile);
}
}
// do checksum - only copy if file has changed
hash = file2md5str(file->tmpfile);
if (!hash) {
LOGERROR("could not compute hash of tmpfile (%s): check permissions\n", file->tmpfile);
ret = 1;
} else {
if (file->currhash)
EUCA_FREE(file->currhash);
file->currhash = hash;
if (check_file(file->dest) || strcmp(file->currhash, file->lasthash)) {
// hashes are different, put new file in place
LOGDEBUG("update triggered due to file update (%s)\n", file->dest);
LOGDEBUG("source and destination file contents have become different, triggering update of dest (%s)\n", file->dest);
LOGDEBUG("renaming file %s -> %s\n", file->tmpfile, file->dest);
if (rename(file->tmpfile, file->dest)) {
LOGERROR("could not rename (move) source file '%s' to dest file '%s': check permissions\n", file->tmpfile, file->dest);
ret = 1;
} else {
EUCA_FREE(file->lasthash);
file->lasthash = strdup(file->currhash);
*file_updated = TRUE;
}
}
}
}
unlink(file->tmpfile);
return (ret);
}
ULONG FASTCALL WG32CreateDIBSection(PVDMFRAME pFrame)
{
ULONG ul = 0;
STACKBMI32 bmi32;
LPBITMAPINFO lpbmi32;
HBITMAP hbm32;
PVOID pv16, pvBits, pvIntelBits;
PVPVOID vpbmi16;
PVOID pvBits32;
DWORD dwArg16;
register PCREATEDIBSECTION16 parg16;
GETARGPTR(pFrame, sizeof(CREATEDIBSECTION16), parg16);
// this is performance hack so we don't generate extra code
dwArg16 = FETCHDWORD(parg16->f4); // do it once here
pv16 = (PVOID)GetPModeVDMPointer(dwArg16, sizeof(DWORD)); // aligned here!
WOW32ASSERTMSG(((parg16->f5 == 0) && (parg16->f6 == 0)),
("WOW:WG32CreateDIBSection, hSection/dwOffset non-null\n"));
vpbmi16 = (PVPVOID)FETCHDWORD(parg16->f2);
lpbmi32 = CopyBMI16ToBMI32(vpbmi16,
(LPBITMAPINFO)&bmi32,
FETCHWORD(parg16->f3));
hbm32 = CreateDIBSection(HDC32(parg16->f1),
lpbmi32,
WORD32(parg16->f3),
&pvBits,
NULL,
0);
if (hbm32 != 0)
{
PARM16 Parm16;
PDIBSECTIONINFO pdi;
ULONG SelectorLimit;
SelectorLimit = (ULONG)cjBitmapBitsSize(lpbmi32);
#ifndef i386
if (!NT_SUCCESS(VdmAddVirtualMemory((ULONG)pvBits,
SelectorLimit,
(PULONG)&pvIntelBits))) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection VdmAddVirtualMemory failed\n"));
goto cds_err;
}
#else
pvIntelBits = pvBits;
#endif
// Create a selector array for the bits backed by pvIntelBits
Parm16.WndProc.wParam = (WORD)-1; // -1 => allocate selectors
Parm16.WndProc.lParam = (LONG) pvIntelBits; // backing pointer
Parm16.WndProc.wMsg = 0x10; // GA_NOCOMPACT
Parm16.WndProc.hwnd = (WORD)((SelectorLimit+65535)/65536);// selector count
CallBack16(RET_SETDIBSEL,
&Parm16,
0,
(PVPVOID)&pvBits32);
// 16:16 pointer is still valid as call above makes no difference
if (pv16 != NULL) {
*(UNALIGNED PVOID*)pv16 = pvBits32;
}
if (pvBits32 == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection, Callback set_sel_for_dib failed\n"));
goto cds_err;
}
#ifndef i386
// okay, that was successful - map the descriptors properly
if (!VdmAddDescriptorMapping(HIWORD(pvBits32),
(USHORT) ((SelectorLimit+65535)/65536),
(ULONG) pvIntelBits,
(ULONG) pvBits)) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection VdmAddDescriptorMapping failed\n"));
goto cds_err;
}
#endif
LOGDEBUG(LOG_ALWAYS, ("\nWOW:CreateDIBSection: [16:16 %x] [Intel %x] [Flat %x]\n",
pvBits32, pvIntelBits, pvBits));
ul = GETHBITMAP16(hbm32);
// Add it to the list used for cleanup at DeleteObject time.
if ((pdi = malloc_w (sizeof (DIBSECTIONINFO))) != NULL) {
pdi->di_hbm = (HBITMAP)(HAND16)hbm32;
pdi->di_pv16 = pvBits32;
#ifndef i386
pdi->di_newIntelDib = pvIntelBits;
#endif
pdi->di_next = pDibSectionInfoHead;
pDibSectionInfoHead = pdi;
// need to turn batching off since a DIBSECTION means the app can
// also draw on the bitmap and we need synchronization.
GdiSetBatchLimit(1);
goto cds_ok;
}
else {
// Failure, free the selector array
Parm16.WndProc.wParam = (WORD)-1; // -1 => allocate/free
Parm16.WndProc.lParam = (LONG) pvBits32; // pointer
Parm16.WndProc.wMsg = 0x10; // GA_NOCOMPACT
Parm16.WndProc.hwnd = 0; // 0 => free
CallBack16(RET_SETDIBSEL,
&Parm16,
0,
(PVPVOID)&ul);
#ifndef i386
VdmRemoveVirtualMemory((ULONG)pvIntelBits);
#endif
}
}
else {
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection, CreateDibSection Failed\n"));
}
cds_err:
if (hbm32 != 0) {
DeleteObject(hbm32);
}
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection returning failure\n"));
ul = 0;
cds_ok:
WOW32APIWARN(ul, "CreateDIBSection");
FREEMISCPTR(pv16);
FREEARGPTR(parg16);
return(ul);
}
//!
//!
//!
//! @param[in] pMeta a pointer to the node controller (NC) metadata structure
//! @param[in] serviceIds
//! @param[in] serviceIdsLen
//!
//! @return
//!
//! @pre
//!
//! @note
//!
int doEnableService(ncMetadata * pMeta, serviceInfoType * serviceIds, int serviceIdsLen)
{
int i = 0;
int rc = 0;
int ret = 0;
int done = 0;
rc = initialize(pMeta, FALSE);
if (rc) {
return (1);
}
LOGDEBUG("invoked: userId=%s\n", SP(pMeta ? pMeta->userId : "UNKNOWN"));
int enable_cc = 0;
for (int i = 0; i < serviceIdsLen; i++) {
if (strcmp(serviceIds[i].type, "cluster") == 0) {
enable_cc = 1;
} else if (strcmp(serviceIds[i].type, "node") == 0) {
ret = doModifyNode(pMeta, serviceIds[i].name, "enabled");
}
}
if (serviceIdsLen < 1) {
enable_cc = 1;
}
if (enable_cc != 1)
goto done;
sem_mywait(CONFIG);
{
if (config->ccState == SHUTDOWNCC) {
LOGWARN("attempt to enable a shutdown CC, skipping.\n");
ret++;
} else if (ccCheckState(0)) {
LOGWARN("ccCheckState() returned failures, skipping.\n");
ret++;
} else if (config->ccState != ENABLED) {
LOGINFO("enabling service\n");
ret = 0;
// tell monitor thread to (re)enable
config->kick_monitor_running = 0;
config->kick_network = 1;
config->kick_dhcp = 1;
config->kick_enabled = 1;
ccChangeState(ENABLED);
}
}
sem_mypost(CONFIG);
if (config->ccState == ENABLED) {
// wait for a minute to make sure CC is running again
done = 0;
for (i = 0; i < 60 && !done; i++) {
sem_mywait(CONFIG);
{
if (config->kick_monitor_running) {
done++;
}
}
sem_mypost(CONFIG);
if (!done) {
LOGDEBUG("waiting for monitor to re-initialize (%d/60)\n", i);
sleep(1);
}
}
}
done:
LOGTRACE("done\n");
return (ret);
}
HDC W32HandleDibDrv (PVPVOID vpbmi16)
{
HDC hdcMem = NULL;
HBITMAP hbm = NULL;
PVOID pvBits, pvIntelBits;
STACKBMI32 bmi32;
LPBITMAPINFO lpbmi32;
DWORD dwClrUsed,nSize,nAlignmentSpace;
PBITMAPINFOHEADER16 pbmi16;
INT nbmiSize,nBytesWritten;
HANDLE hfile=NULL,hsec=NULL;
ULONG RetVal,OriginalSelLimit,SelectorLimit,OriginalFlags;
PARM16 Parm16;
CHAR pchTempFile[MAX_PATH];
BOOL bRet = FALSE;
PVPVOID vpBase16 = (PVPVOID) ((ULONG) vpbmi16 & 0xffff0000);
if ((hdcMem = W32FindAndLockDibInfo((USHORT)HIWORD(vpbmi16))) != (HDC)NULL) {
return hdcMem;
}
// First create a memory device context compatible to
// the app's current screen
if ((hdcMem = CreateCompatibleDC (NULL)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateCompatibleDC failed\n"));
return NULL;
}
// Copy bmi16 to bmi32. DIB.DRV only supports DIB_RGB_COLORS
lpbmi32 = CopyBMI16ToBMI32(
vpbmi16,
(LPBITMAPINFO)&bmi32,
(WORD) DIB_RGB_COLORS);
// this hack for Director 4.0 does essentially what WFW does
// if this bitmap is 0 sized, just return an hDC for something simple
if(bmi32.bmiHeader.biSizeImage == 0 &&
(CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_DIBDRVIMAGESIZEZERO)) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv:Zero biSizeImage, returning memory DC!\n"));
return hdcMem;
}
try {
// Copy the wholething into a temp file. First get a temp file name
if ((nSize = GetTempPath (MAX_PATH, pchTempFile)) == 0 ||
nSize >= MAX_PATH)
goto hdd_err;
if (GetTempFileName (pchTempFile,
"DIB",
0,
pchTempFile) == 0)
goto hdd_err;
if ((hfile = CreateFile (pchTempFile,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
(FILE_ATTRIBUTE_NORMAL |
FILE_ATTRIBUTE_TEMPORARY |
FILE_FLAG_DELETE_ON_CLOSE),
NULL)) == INVALID_HANDLE_VALUE) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateFile failed\n"));
goto hdd_err;
}
// call back to get the size of the global object
// associated with vpbmi16
Parm16.WndProc.wParam = HIWORD(vpbmi16);
CallBack16(RET_GETDIBSIZE,
&Parm16,
0,
(PVPVOID)&SelectorLimit);
Parm16.WndProc.wParam = HIWORD(vpbmi16);
if (SelectorLimit == 0xffffffff || SelectorLimit == 0) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv Invalid Selector %x\n",HIWORD(vpbmi16)));
goto hdd_err;
}
SelectorLimit++;
OriginalSelLimit = SelectorLimit;
CallBack16(RET_GETDIBFLAGS,
&Parm16,
0,
(PVPVOID)&OriginalFlags);
if (OriginalFlags == 0x4) { //GA_DGROUP
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv GA_DGROUP Not Handled\n"));
goto hdd_err;
}
GETVDMPTR(vpBase16, SelectorLimit, pbmi16);
nbmiSize = GetBMI16Size(vpbmi16, (WORD) DIB_RGB_COLORS, &dwClrUsed);
// Under NT CreateDIBSection will fail if the offset to the bits
// is not dword aligned. So we may have to add some space at the top
// of the section to get the offset correctly aligned.
nAlignmentSpace = (nbmiSize+LOWORD(vpbmi16)) % 4;
if (nAlignmentSpace) {
if (WriteFile (hfile,
pbmi16,
nAlignmentSpace,
&nBytesWritten,
NULL) == FALSE ||
nBytesWritten != (INT) nAlignmentSpace)
goto hdd_err;
}
//
// detect a clinical case of bitedit screwing around dib.drv
//
// code below is using dib macros declared in wdib.h
// namely:
// DibNumColors - yields max number of colors in dib
// DibColors - yields pointer to a dib color table
//
// Function W32CheckDibColorIndices checks to see if DIB color
// table looks like a number (defined usually by biClrImportant)
// of WORD indices in a sequential order (0, 1, 2, ...)
// if this is the case, app is trying to use undocumented feature
// of DIB.DRV that turns color matching off in this case.
// Since we cannot enforce that rule, we approximate it by filling
// color table by a number of known (and always same) entries
// When blitting occurs, no color matching will be performed (when
// both target and destination are of this very nature).
// For no reason at all we fill color table with vga colors.
// Sequential indices could have worked just as well.
//
// Modifications are made to memory pointed to by lpbmi32
if (W32CheckDibColorIndices((LPBITMAPINFOHEADER)lpbmi32)) {
INT i, nColors;
LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER)lpbmi32;
LPRGBQUAD lprgbq = (LPRGBQUAD)DibColors(lpbmi);
nColors = DibNumColors(lpbmi);
lpbmi->biClrImportant = nColors;
switch (lpbmi->biBitCount) {
case 1:
lprgbq[0] = rgbVGA[0];
lprgbq[1] = rgbVGA[0x0f];
break;
case 4:
RtlCopyMemory(lprgbq, rgbVGA, sizeof(rgbVGA));
break;
case 8:
RtlCopyMemory(lprgbq, rgbVGA, 8*sizeof(RGBQUAD));
RtlCopyMemory(lprgbq+248, rgbVGA+8, 8*sizeof(RGBQUAD));
RtlCopyMemory(lprgbq+8, rgb4, 2*sizeof(RGBQUAD));
RtlCopyMemory(lprgbq+246, rgb4+2, 2*sizeof(RGBQUAD));
for (i = 10; i < 246; ++i) {
lprgbq[i].rgbBlue = i;
lprgbq[i].rgbGreen= 0;
lprgbq[i].rgbRed = 0;
lprgbq[i].rgbReserved = 0;
}
break;
default: // this should never happen
break;
}
}
if (WriteFile (hfile,
pbmi16,
SelectorLimit,
&nBytesWritten,
NULL) == FALSE || nBytesWritten != (INT) SelectorLimit)
goto hdd_err;
if (SelectorLimit < 64*1024) {
if (SetFilePointer (hfile,
64*1024+nAlignmentSpace,
NULL,
FILE_BEGIN) == -1)
goto hdd_err;
if (SetEndOfFile (hfile) == FALSE)
goto hdd_err;
SelectorLimit = 64*1024;
}
if ((hsec = CreateFileMapping (hfile,
NULL,
PAGE_READWRITE | SEC_COMMIT,
0,
SelectorLimit+nAlignmentSpace,
NULL)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateFileMapping Failed\n"));
goto hdd_err;
}
// Now create the DIB section
if ((hbm = CreateDIBSection (hdcMem,
lpbmi32,
DIB_RGB_COLORS,
&pvBits,
hsec,
nAlignmentSpace + LOWORD(vpbmi16) + nbmiSize
)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateDibSection Failed\n"));
goto hdd_err;
}
FREEVDMPTR(pbmi16);
if((pvBits = MapViewOfFile(hsec,
FILE_MAP_WRITE,
0,
0,
SelectorLimit+nAlignmentSpace)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv MapViewOfFile Failed\n"));
goto hdd_err;
}
pvBits = (PVOID) ((ULONG)pvBits + nAlignmentSpace);
SelectObject (hdcMem, hbm);
GdiSetBatchLimit(1);
#ifndef i386
if (!NT_SUCCESS(VdmAddVirtualMemory((ULONG)pvBits,
(ULONG)SelectorLimit,
(PULONG)&pvIntelBits))) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv VdmAddVirtualMemory failed\n"));
goto hdd_err;
}
// On risc platforms, the intel base + the intel linear address
// of the DIB section is not equal to the DIB section's process
// address. This is because of the VdmAddVirtualMemory call
// above. So here we zap the correct address into the flataddress
// array.
if (!VdmAddDescriptorMapping(HIWORD(vpbmi16),
(USHORT) ((SelectorLimit+65535)/65536),
(ULONG) pvIntelBits,
(ULONG) pvBits)) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv VdmAddDescriptorMapping failed\n"));
goto hdd_err;
}
#else
pvIntelBits = pvBits;
#endif
// Finally set the selectors to the new DIB
Parm16.WndProc.wParam = HIWORD(vpbmi16);
Parm16.WndProc.lParam = (LONG)pvIntelBits;
Parm16.WndProc.wMsg = 0x10; // GA_NOCOMPACT
Parm16.WndProc.hwnd = 1; // set so it's not randomly 0
CallBack16(RET_SETDIBSEL,
&Parm16,
0,
(PVPVOID)&RetVal);
if (!RetVal) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv Callback set_sel_for_dib failed\n"));
goto hdd_err;
}
// Store all the relevant information so that DeleteDC could
// free all the resources later.
if (W32AddDibInfo(hdcMem,
hfile,
hsec,
nAlignmentSpace,
pvBits,
pvIntelBits,
hbm,
OriginalSelLimit,
(USHORT)OriginalFlags,
(USHORT)((HIWORD(vpbmi16)))) == FALSE)
goto hdd_err;
// Finally spit out the dump for debugging
LOGDEBUG(6,("\t\tWOW::W32HandleDibDrv hdc=%04x nAlignment=%04x\n\t\tNewDib=%x OldDib=%04x:%04x DibSize=%x DibFlags=%x\n",hdcMem,nAlignmentSpace,pvBits,HIWORD(vpbmi16),LOWORD(vpbmi16),OriginalSelLimit,(USHORT)OriginalFlags));
bRet = TRUE;
hdd_err:;
}
finally {
if (!bRet) {
if (hdcMem) {
DeleteDC (hdcMem);
hdcMem = NULL;
}
if (hfile)
CloseHandle (hfile);
if (hsec)
CloseHandle (hsec);
if (hbm)
CloseHandle (hbm);
}
}
return hdcMem;
}
int
_ds_init_storage (DSPAM_CTX * CTX, void *dbh)
{
struct _hash_drv_storage *s = NULL;
hash_drv_map_t map = NULL;
int ret;
if (CTX == NULL)
return EINVAL;
if (!CTX->home) {
LOG(LOG_ERR, ERR_AGENT_DSPAM_HOME);
return EINVAL;
}
if (CTX->flags & DSF_MERGED) {
LOG(LOG_ERR, ERR_DRV_NO_MERGED);
return EINVAL;
}
if (CTX->storage)
return EINVAL;
/* Persistent driver storage */
s = calloc (1, sizeof (struct _hash_drv_storage));
if (s == NULL)
{
LOG(LOG_CRIT, ERR_MEM_ALLOC);
return EUNKNOWN;
}
/* If running in HashConcurrentUser mode, use existing hash mapping */
if (dbh) {
map = dbh;
s->dbh_attached = 1;
} else {
map = calloc(1, sizeof(struct _hash_drv_map));
if (!map) {
LOG(LOG_CRIT, ERR_MEM_ALLOC);
free(s);
return EUNKNOWN;
}
s->dbh_attached = 0;
}
s->map = map;
/* Mapping defaults */
s->hash_rec_max = HASH_REC_MAX;
s->max_seek = HASH_SEEK_MAX;
s->max_extents = 0;
s->extent_size = HASH_EXTENT_MAX;
s->pctincrease = 0;
s->flags = HMAP_AUTOEXTEND;
if (READ_ATTRIB("HashRecMax"))
s->hash_rec_max = strtol(READ_ATTRIB("HashRecMax"), NULL, 0);
if (READ_ATTRIB("HashExtentSize"))
s->extent_size = strtol(READ_ATTRIB("HashExtentSize"), NULL, 0);
if (READ_ATTRIB("HashMaxExtents"))
s->max_extents = strtol(READ_ATTRIB("HashMaxExtents"), NULL, 0);
if (!MATCH_ATTRIB("HashAutoExtend", "on"))
s->flags = 0;
if (READ_ATTRIB("HashPctIncrease")) {
s->pctincrease = atoi(READ_ATTRIB("HashPctIncrease"));
if (s->pctincrease > 100) {
LOG(LOG_ERR, "HashPctIncrease out of range; ignoring");
s->pctincrease = 0;
}
}
if (READ_ATTRIB("HashMaxSeek"))
s->max_seek = strtol(READ_ATTRIB("HashMaxSeek"), NULL, 0);
if (!dbh && CTX->username != NULL)
{
char db[MAX_FILENAME_LENGTH];
int lock_result;
if (CTX->group == NULL)
_ds_userdir_path(db, CTX->home, CTX->username, "css");
else
_ds_userdir_path(db, CTX->home, CTX->group, "css");
lock_result = _hash_drv_lock_get (CTX, s,
(CTX->group) ? CTX->group : CTX->username);
if (lock_result < 0)
goto BAIL;
ret = _hash_drv_open(db, s->map, s->hash_rec_max, s->max_seek,
s->max_extents, s->extent_size, s->pctincrease, s->flags);
if (ret) {
_hash_drv_close(s->map);
free(s);
return EFAILURE;
}
}
CTX->storage = s;
s->dir_handles = nt_create (NT_INDEX);
if (_hash_drv_get_spamtotals (CTX))
{
LOGDEBUG ("unable to load totals. using zero values.");
memset (&CTX->totals, 0, sizeof (struct _ds_spam_totals));
}
return 0;
BAIL:
free(s);
return EFAILURE;
}
int _ds_tokenize_sparse(
DSPAM_CTX *CTX,
char *headers,
char *body,
ds_diction_t diction)
{
int i;
char *token; /* current token */
char *previous_tokens[SPARSE_WINDOW_SIZE]; /* sparse chain */
char *line = NULL; /* header broken up into lines */
char *ptrptr;
char *bitpattern;
char heading[128]; /* current heading */
int l;
struct nt *header = NULL;
struct nt_node *node_nt;
struct nt_c c_nt;
for(i=0; i<SPARSE_WINDOW_SIZE; i++)
previous_tokens[i] = NULL;
bitpattern = _ds_generate_bitpattern(_ds_pow2(SPARSE_WINDOW_SIZE));
/* Tokenize URLs in message */
if (_ds_match_attribute(CTX->config->attributes, "ProcessorURLContext", "on"))
{
_ds_url_tokenize(diction, body, "http://");
_ds_url_tokenize(diction, body, "www.");
_ds_url_tokenize(diction, body, "href=");
}
/*
* Header Tokenization
*/
header = nt_create (NT_CHAR);
if (header == NULL)
{
LOG (LOG_CRIT, ERR_MEM_ALLOC);
free(bitpattern);
return EUNKNOWN;
}
line = strtok_r (headers, "\n", &ptrptr);
while (line) {
nt_add (header, line);
line = strtok_r (NULL, "\n", &ptrptr);
}
node_nt = c_nt_first (header, &c_nt);
heading[0] = 0;
while (node_nt) {
int multiline;
#ifdef VERBOSE
LOGDEBUG("processing line: %s", node_nt->ptr);
#endif
_ds_sparse_clear(previous_tokens);
line = static_cast<char *>(node_nt->ptr);
token = strtok_r (line, ":", &ptrptr);
if (token && token[0] != 32 && token[0] != 9 && !strstr (token, " "))
{
multiline = 0;
strlcpy (heading, token, 128);
_ds_sparse_clear(previous_tokens);
} else {
multiline = 1;
}
#ifdef VERBOSE
LOGDEBUG ("Reading '%s' header from: '%s'", heading, line);
#endif
if (CTX->flags & DSF_WHITELIST) {
/* Use the entire From: line for auto-whitelisting */
if (!strcmp(heading, "From")) {
char wl[256];
char *fromline = line + 5;
unsigned long long whitelist_token;
if (fromline[0] == 32)
fromline++;
snprintf(wl, sizeof(wl), "%s*%s", heading, fromline);
whitelist_token = _ds_getcrc64(wl);
ds_diction_touch(diction, whitelist_token, wl, 0);
diction->whitelist_token = whitelist_token;
}
}
/* Received headers use a different set of delimiters to preserve things
like ip addresses */
token = strtok_r ((multiline) ? line : NULL, SPARSE_DELIMITERS_HEADING, &ptrptr);
while (token)
{
l = strlen(token);
if (l > 0 && l < 50)
{
#ifdef VERBOSE
LOGDEBUG ("Processing '%s' token in '%s' header", token, heading);
#endif
_ds_map_header_token (CTX, token, previous_tokens, diction, heading, bitpattern);
}
token = strtok_r (NULL, SPARSE_DELIMITERS_HEADING, &ptrptr);
}
for(i=0; i<SPARSE_WINDOW_SIZE; i++) {
_ds_map_header_token(CTX, NULL, previous_tokens, diction, heading, bitpattern);
}
_ds_sparse_clear(previous_tokens);
node_nt = c_nt_next (header, &c_nt);
}
nt_destroy (header);
/*
* Body Tokenization
*/
#ifdef VERBOSE
LOGDEBUG("parsing message body");
#endif
token = strtok_r (body, SPARSE_DELIMITERS, &ptrptr);
while (token != NULL)
{
l = strlen (token);
if (l > 0 && l < 50)
{
#ifdef VERBOSE
LOGDEBUG ("Processing body token '%s'", token);
#endif
/* Process "current" token */
_ds_map_body_token (CTX, token, previous_tokens, diction, bitpattern);
}
token = strtok_r (NULL, SPARSE_DELIMITERS, &ptrptr);
}
for(i=0; i<SPARSE_WINDOW_SIZE; i++) {
_ds_map_body_token(CTX, NULL, previous_tokens, diction, bitpattern);
}
_ds_sparse_clear(previous_tokens);
free(bitpattern);
#ifdef VERBOSE
LOGDEBUG("Finished tokenizing (sparse) message");
#endif
return 0;
}
/// Creates the underlying O/S file handle.
///
/// @param[in] pszName name of the pipe
/// @param[in] bServer true if this is a server end, false if it is a client
/// @param[in] bExclusive false if this is a pipe that can be shared by multiple clients or servers
/// @param[in] bReader true if this is the reading end of a pipe, false if it is the writing end
/// @return the O/S file handle
static CTimeoutIO::FILE_REFERENCE _CreatePipe (const TCHAR *pszName, bool bServer, bool bExclusive, bool bReader) {
#ifdef _WIN32
HANDLE handle;
if (bServer) {
SECURITY_DESCRIPTOR sd;
SECURITY_ATTRIBUTES sa;
InitializeSecurityDescriptor (&sd, SECURITY_DESCRIPTOR_REVISION);
// TODO [PLAT-1119] Get a SDDL from the registry for the DACL (and pass it into this library)
SetSecurityDescriptorDacl (&sd, TRUE, NULL, FALSE);
ZeroMemory (&sa, sizeof (sa));
sa.nLength = sizeof (sa);
sa.lpSecurityDescriptor = &sd;
sa.bInheritHandle = FALSE;
handle = CreateNamedPipe (
pszName,
(bReader ? PIPE_ACCESS_INBOUND : PIPE_ACCESS_OUTBOUND) | (bExclusive ? FILE_FLAG_FIRST_PIPE_INSTANCE : 0) | FILE_FLAG_OVERLAPPED,
(bExclusive ? PIPE_TYPE_BYTE | PIPE_READMODE_BYTE : PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE) | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS,
bExclusive ? 1 : PIPE_UNLIMITED_INSTANCES,
0,
0,
0,
&sa);
} else {
// TODO: share or exclusive? We want a 1:1 on the pipe we've connected to - the server will open another for new clients
handle = CreateFile (pszName, bReader ? GENERIC_READ : GENERIC_WRITE, 0/* bReader ? FILE_SHARE_READ : FILE_SHARE_WRITE */, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
}
if (handle == INVALID_HANDLE_VALUE) {
DWORD dwError = GetLastError ();
LOGWARN (TEXT ("Couldn't create pipe ") << pszName << TEXT(", error ") << dwError);
SetLastError (dwError);
return NULL;
}
LOGINFO (TEXT ("Created pipe ") << pszName);
return handle;
#else /* ifdef _WIN32 */
if (bExclusive) {
if (mkfifo (pszName, 0666)) {
int ec = GetLastError ();
LOGWARN (TEXT ("Couldn't create pipe ") << pszName << TEXT (", error ") << ec);
SetLastError (ec);
return 0;
}
CThread *poOpener = new CNamedPipeOpenThread (pszName, bReader ? O_WRONLY : O_RDONLY);
poOpener->Start ();
CThread::Release (poOpener);
int file = open (pszName, bReader ? O_RDONLY : O_WRONLY);
if (file <= 0) {
int ec = GetLastError ();
LOGWARN (TEXT ("Couldn't open pipe ") << pszName << TEXT (", error ") << ec);
if (unlink (pszName)) {
LOGWARN (TEXT ("Couldn't delete pipe ") << pszName << TEXT (", error ") << GetLastError ());
}
SetLastError (ec);
return 0;
}
LOGINFO (TEXT ("Created pipe ") << pszName);
return file;
} else {
int sock;
sock = socket (AF_UNIX, SOCK_STREAM, 0);
if (sock < 0) {
int ec = GetLastError ();
LOGWARN (TEXT ("Couldn't open pipe ") << pszName << TEXT (", error ") << ec);
SetLastError (ec);
return 0;
}
if (!_SetDefaultSocketOptions (sock)) {
int ec = GetLastError ();
close (sock);
LOGWARN (TEXT ("Couldn't set default options ") << pszName << TEXT (", error ") << ec);
SetLastError (ec);
return 0;
}
struct sockaddr_un addr;
addr.sun_family = AF_UNIX;
StringCbPrintf (addr.sun_path, sizeof (addr.sun_path), TEXT ("%s"), pszName);
if (bServer) {
if (!unlink (pszName)) {
LOGINFO (TEXT ("Deleted previous instance of ") << pszName);
}
if (bind (sock, (struct sockaddr*)&addr, sizeof (addr.sun_family) + _tcslen (addr.sun_path))) {
int ec = GetLastError ();
close (sock);
LOGWARN (TEXT ("Couldn't open pipe ") << pszName << TEXT (", error ") << ec);
SetLastError (ec);
return 0;
}
if (fcntl (sock, F_SETFL, O_NONBLOCK) || listen (sock, 0)) {
int ec = GetLastError ();
close (sock);
LOGWARN (TEXT ("Couldn't open pipe ") << pszName << TEXT (", error ") << ec);
SetLastError (ec);
return 0;
}
LOGINFO (TEXT ("Created server Unix Domain Socket ") << pszName);
} else {
if (connect (sock, (struct sockaddr*)&addr, sizeof (addr.sun_family) + _tcslen (addr.sun_path))) {
int ec = GetLastError ();
close (sock);
LOGWARN (TEXT ("Couldn't open pipe ") << pszName << TEXT (", error ") << ec);
switch (ec) {
case EAGAIN :
LOGDEBUG (TEXT ("Translating EAGAIN to ENOENT"));
ec = ENOENT;
break;
case ECONNREFUSED :
LOGDEBUG (TEXT ("Translating ECONNREFUSED to ENOENT"));
ec = ENOENT;
break;
}
SetLastError (ec);
return 0;
}
LOGDEBUG (TEXT ("Connection accepted, waiting for handshake confirmation"));
if ((recv (sock, addr.sun_path, 1, 0) != 1) || fcntl (sock, F_SETFL, O_NONBLOCK)) {
int ec = GetLastError ();
close (sock);
LOGWARN (TEXT ("Handshake not received on ") << pszName << TEXT (", error ") << ec);
switch (ec) {
case EAGAIN :
LOGDEBUG (TEXT ("Translating EAGAIN to ENOENT"));
ec = ENOENT;
break;
}
SetLastError (ec);
return 0;
}
LOGINFO (TEXT ("Connected to Unix Domain Socket ") << pszName);
}
return sock;
}
#endif /* ifdef _WIN32 */
}
bool FileWatcher::StartWatching(const String& pathName, bool watchSubDirs)
{
if (!fileSystem_)
{
LOGERROR("No FileSystem, can not start watching");
return false;
}
// Stop any previous watching
StopWatching();
#if defined(ENABLE_FILEWATCHER)
#if defined(WIN32)
String nativePath = GetNativePath(RemoveTrailingSlash(pathName));
dirHandle_ = (void*)CreateFileW(
WString(nativePath).CString(),
FILE_LIST_DIRECTORY,
FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE,
0,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS,
0);
if (dirHandle_ != INVALID_HANDLE_VALUE)
{
path_ = AddTrailingSlash(pathName);
watchSubDirs_ = watchSubDirs;
Start();
LOGDEBUG("Started watching path " + pathName);
return true;
}
else
{
LOGERROR("Failed to start watching path " + pathName);
return false;
}
#elif defined(__linux__)
int flags = IN_CREATE|IN_DELETE|IN_MODIFY|IN_MOVED_FROM|IN_MOVED_TO;
int handle = inotify_add_watch(watchHandle_, pathName.CString(), flags);
if (handle < 0)
{
LOGERROR("Failed to start watching path " + pathName);
return false;
}
else
{
// Store the root path here when reconstructed with inotify later
dirHandle_[handle] = "";
path_ = AddTrailingSlash(pathName);
watchSubDirs_ = watchSubDirs;
if (watchSubDirs_)
{
Vector<String> subDirs;
fileSystem_->ScanDir(subDirs, pathName, "*", SCAN_DIRS, true);
for (unsigned i = 0; i < subDirs.Size(); ++i)
{
String subDirFullPath = AddTrailingSlash(path_ + subDirs[i]);
// Don't watch ./ or ../ sub-directories
if (!subDirFullPath.EndsWith("./"))
{
handle = inotify_add_watch(watchHandle_, subDirFullPath.CString(), flags);
if (handle < 0)
LOGERROR("Failed to start watching subdirectory path " + subDirFullPath);
else
{
// Store sub-directory to reconstruct later from inotify
dirHandle_[handle] = AddTrailingSlash(subDirs[i]);
}
}
}
}
Start();
LOGDEBUG("Started watching path " + pathName);
return true;
}
#elif defined(__APPLE__) && !defined(IOS)
if (!supported_)
{
LOGERROR("Individual file watching not supported by this OS version, can not start watching path " + pathName);
return false;
}
watcher_ = CreateFileWatcher(pathName.CString(), watchSubDirs);
if (watcher_)
{
path_ = AddTrailingSlash(pathName);
watchSubDirs_ = watchSubDirs;
Start();
LOGDEBUG("Started watching path " + pathName);
return true;
}
else
{
LOGERROR("Failed to start watching path " + pathName);
return false;
}
#else
LOGERROR("FileWatcher not implemented, can not start watching path " + pathName);
return false;
#endif
#else
LOGDEBUG("FileWatcher feature not enabled");
return false;
#endif
}
