/* Returns the variable with the given name in the query.
If not found:
if the query is running, return NULL
otherwise create a new variable with the given name.
if there isn't enough memory, return NULL.
*/
PR_PUBLIC_API(RDF_Variable) RDF_GetVariable(RDF_Query q, char* name) {
RDF_Variable newvar;
RDF_VariableList newlist;
RDF_VariableList current = q->variables;
while (current != NULL) {
if (stringEquals(current->element->id, name)) return current->element;
if (current->next == NULL) break;
else current = current->next;
}
if (q->queryRunning) return NULL;
newvar = (RDF_Variable)getMem(sizeof(RDF_VariableStruc));
if (newvar == NULL) return NULL;
newvar->id = copyString(name);
newvar->query = q;
/* create a list containing the variable and append it to the front of the variable list */
newlist = (RDF_VariableList)getMem(sizeof(RDF_VariableListStruc));
if (newlist == NULL) {
freeMem(newvar);
return NULL;
}
newlist->element = newvar;
newlist->next = q->variables;
q->variables = newlist;
return newvar;
}
struct addrinfo *getAddressInfo(char *hostName, char *port) {
//printf("Getting Address Info of host: %s port: %s\n",hostName, port);
//hostName = "localhost";
struct addrinfo hints, *host_info_list;
memset(&hints, 0, sizeof hints); //clear any hint
hints.ai_socktype = SOCK_STREAM;
hints.ai_family = AF_INET;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags = AI_PASSIVE;
int result;
if (stringEquals(hostName, "localhost")) {
result = getaddrinfo(NULL, port, &hints, &host_info_list);
}
else {
result = getaddrinfo(hostName, port, &hints, &host_info_list);
}
if (result != 0 || host_info_list == NULL) {
fprintf(stderr, "Error Getting AddressInfo: %s\n", gai_strerror(result));
printf("Unable to get the AddressInfo. Please check the hostname/ipAddress provided.\n");
return NULL;
}
// if(host_info_list->ai_next!=NULL)
// cerr << "More than one IPv4 addresses returned";
struct addrinfo *tempAddrInfo = host_info_list;
return tempAddrInfo;
}
int connectToClient(char *hostName, char *port) {
//check if the host is trying to connect to itself
if ((stringEquals(hostName, myHostName) || stringEquals(hostName, myIpAddress))
&& (stringEquals(port, myListenerPort))) {
printf("You can't connect to yourself.\n");
return -1;
}
//Check if hostname/ip and port is registered to server
if (!isHostPresent(peerList, hostName, port)) {
printf("The client you are trying to connect to is not registered with the server.\n");
return -1;
}
//duplicate connection
if (isHostPresent(connectionList, hostName, port)) {
printf("You are already connected to %s/%s.\n", hostName, port);
return -1;
}
//check if the user entered a ipAddress or hostName
if (stringEquals(getIpfromHost(hostName), hostName)) {
//if true the user entered an ipaddress
hostName = getHostFromIp(hostName);
}
//printf("Connecting to %s/%s.\n", hostName, port);
int clientSockfd = connectToHost(hostName, port); //"localhost" should be hostName #needtomodify
if (clientSockfd == -1) {
fprintf(stderr, "Error connecting to client\n");
}
else {
//add the client to the connectionList
struct host *client = (struct host *) malloc(sizeof(struct host));
client->id = connectionIdGenerator++;
client->sockfd = clientSockfd;
client->ipAddress = getIpfromHost(hostName);
client->hostName = hostName;
client->port = port;
addNode(&connectionList, client);
printf("Connected to %s/%s\n", client->hostName, client->port);
}
return 0;
}
cpConstraint *cpSpaceSerializer::createConstraint(TiXmlElement *elm)
{
cpConstraint *constraint = NULL;
const char* type = elm->Attribute("type");
if (stringEquals(type, "pin"))
constraint = createPinJoint(elm);
else if (stringEquals(type, "slide"))
constraint = createSlideJoint(elm);
else if (stringEquals(type, "pivot"))
constraint = createPivotJoint(elm);
else if (stringEquals(type, "groove"))
constraint = createGrooveJoint(elm);
else if (stringEquals(type, "motor"))
constraint = createMotorJoint(elm);
else if (stringEquals(type, "gear"))
constraint = createGearJoint(elm);
else if (stringEquals(type, "spring"))
constraint = createSpringJoint(elm);
else if (stringEquals(type, "rotaryLimit"))
constraint = createRotaryLimitJoint(elm);
else if (stringEquals(type, "ratchet"))
constraint = createRatchetJoint(elm);
else if (stringEquals(type, "rotarySpring"))
constraint = createRotarySpringJoint(elm);
else
return NULL;
CPSS_ID id = createValue<CPSS_ID>("id", elm);
constraint->maxForce = createValue<cpFloat>("maxForce", elm);
constraint->errorBias = createValue<cpFloat>("errorBias", elm);
constraint->maxBias = createValue<cpFloat>("maxBias", elm);
if (delegate)
{
if (!delegate->reading(constraint, id))
{
cpConstraintFree(constraint);
constraint = NULL;
}
}
return constraint;
}
int find_name_already(char * name, char ** list, int count)
{
int i;
for (i = 0; i < count; i++)
{
if (stringEquals(name, list[i]))
return true;
}
return false;
}
int get_r_request(int * list, char* name, int type, int log_count)
{
int i, count = 0;
for (i = 0; i < log_count; i++)
{
if (stringEquals(logarray[i].name, name) && logarray[i].type == type &&
isRoom(logarray[i].where))
list[count++] = logarray[i].where;
}
return count;
}
int locate_string(char **stringArray, char * string)
{
int i=0;
while(stringArray[i]!=0){
if(stringEquals(stringArray[i], string)){
return i;
}
i++;
}
return -1;
}
int check_if_in_room(char *name, int log_count,int roomid)
{
int where = OUTGALARY;
int i;
for (i = 0; i < log_count; i++)
if (stringEquals(logarray[i].name, name))
where = logarray[i].where;
if (where == roomid)
return true;
return false;
}
cpShape *cpSpaceSerializer::createShape(TiXmlElement *elm)
{
cpShape *shape;
const char* type = elm->Attribute("type");
if (stringEquals(type, "circle"))
shape = createCircle(elm);
else if (stringEquals(type, "segment"))
shape = createSegment(elm);
else if (stringEquals(type, "poly"))
shape = createPoly(elm);
else
return NULL;
CPSS_ID id = createValue<CPSS_ID>("id", elm);
_shapeMap[id] = shape;
shape->sensor = createValue<int>("sensor", elm);
shape->e = createValue<cpFloat>("e", elm);
shape->u = createValue<cpFloat>("u", elm);
shape->surface_v = createPoint("surface_v", elm);
shape->collision_type = createValue<cpCollisionType>("collision_type", elm);
shape->group = createValue<cpGroup>("group", elm);
shape->layers = createValue<cpLayers>("layers", elm);
if (delegate)
{
if (!delegate->reading(shape, id))
{
if (shape->body != _space->staticBody)
cpBodyFree(shape->body);
cpShapeFree(shape);
shape = NULL;
}
}
return shape;
}
unsigned int path_to_inum(int fd, std::vector<std::string>& path, int inum, int pathPos) {
//dout << path << " " << inum << std::endl;
//Get the first directory name in the path
char delim = '/';
std::string dir;
if(pathPos < path.size()) {
//Read the inode which represents a directory
//and look for a file whose name matches dir
dir = path[pathPos];
char buffer[BLOCK_SIZE] = {};
unsigned int block = 0;
ByteAndBlock* rtnVal;
rtnVal = copyBlock(fd, inum, block);
lseek(fd, rtnVal->block * BLOCK_SIZE, SEEK_SET);
read(fd, buffer, BLOCK_SIZE);
while(rtnVal->bytesRead > 0) {
for(int offset = 0; offset < rtnVal->bytesRead; offset += DIR_SIZE) {
std::string name(buffer + offset + sizeof(unsigned int), DIR_SIZE - sizeof(unsigned int));
if(stringEquals(dir, name)) {
delete rtnVal;
return path_to_inum(fd, path, read_long(buffer + offset, sizeof(int)), pathPos + 1);
}
}
delete rtnVal;
rtnVal = copyBlock(fd, inum, block++);
lseek(fd, rtnVal->block * BLOCK_SIZE, SEEK_SET);
read(fd, buffer, BLOCK_SIZE);
}
delete rtnVal;
return -1;
} else {
return inum;
}
}
void
possiblyAccessldap(RDFT rdf, RDF_Resource u, RDF_Resource s, PRBool inversep)
{
/** try to get the values of u.s from the directory **/
LDAP *ld;
LDAPMessage *result=NULL, *entry;
LDAPURLDesc *ldURL=NULL;
RDF_Resource node;
char *attrs[2], **vals;
int err, i;
char *title = NULL;
/*
Note: a labeledURI is a url followed by an optional [space title-string]
*/
if (!stringEquals(resourceID(s), resourceID(gCoreVocab->RDF_parent)) || (!inversep) || (!ldap_is_ldap_url(resourceID(u)))) return;
ldap_url_parse(resourceID(u), &ldURL);
if (ldURL == NULL) return;
ld = ldap_init (ldURL->lud_host, ldURL->lud_port);
if (ld == NULL)
{
ldap_free_urldesc(ldURL);
return;
}
if ((err = ldap_simple_bind_s(ld, NULL, NULL)) != LDAP_SUCCESS)
{
ldap_unbind(ld);
ldap_free_urldesc(ldURL);
return;
}
attrs[0] = "labeledURI";
attrs[1] = NULL;
err = ldap_search_s(ld, ldURL->lud_dn, LDAP_SCOPE_BASE, ldURL->lud_filter, attrs, 0, &result);
if (err == LDAP_SUCCESS)
{
for (entry=ldap_first_entry(ld, result); entry!=NULL; entry=ldap_next_entry(ld, entry))
{
if ((vals = ldap_get_values(ld, entry, attrs[0])) != NULL)
{
for (i=0; vals[i] != NULL; i++)
{
/* vals[i] has a URL... add into RDF graph */
/*
if (((title = strstr(vals[i], " ")) != NULL)
&& (*(title+1) != '\0'))
{
*(++title) = '\0';
}
else
{
title = NULL;
}
*/
if ((node = RDF_Create(vals[i], true)) != NULL)
{
setResourceType(node, LDAP_RT);
if (ldapContainerp(node) == true)
{
setContainerp(node, 1);
}
ldapDBAdd(rdf, node, gCoreVocab->RDF_parent,
u, RDF_RESOURCE_TYPE);
if (title != NULL)
{
ldapDBAdd(rdf, node, gCoreVocab->RDF_name,
title, RDF_STRING_TYPE);
}
}
}
ldap_value_free(vals);
}
}
}
if (result != NULL)
{
ldap_msgfree(result);
}
ldap_unbind(ld);
ldap_free_urldesc(ldURL);
}
static bool elementEquals(TiXmlNode *elm, const char* value)
{
return stringEquals(elm->Value(), value);
}
void interpretPrompt(References* r, CPUStatus* cpu, int* status)
{
// show prompt ready
printf("> ");
fflush(stdout);
// get new command
char* line = (char*) calloc(MAX_STRING_LENGTH, sizeof(char));
if (line == NULL)
{
perror("calloc error in interpretPrompt\n");
exit(EXIT_FAILURE);
}
if (fgets(line, MAX_STRING_LENGTH, stdin) == NULL)
{
perror("fgets error in interpretPrompt\n");
exit(EXIT_FAILURE);
}
// remove endline
removeEndLine(line);
int assembleCode = 0;
// interpreter commands
if (stringEquals(line, "regs") == 0)
{
printRegisters(cpu);
*status = RUN_COMMAND;
free(line);
return;
} else if (stringEquals(line, "mem") == 0)
{
printMemory(cpu);
*status = RUN_COMMAND;
free(line);
return;
} else if (stringEquals(line, "exit") == 0)
{
*status = EXECUTE_HALT;
free(line);
return;
} else if (stringEquals(line, "show") == 0)
{
printInstructions(r);
*status = RUN_COMMAND;
free(line);
return;
} else
{
// assemble One Pass
assembleCode = onePass(r, cpu, line);
}
// execute interpreter
if (assembleCode == ASSEMBLE_OK ||
(assembleCode == ASSEMBLE_LABEL && r->currentAddress > 4))
{
interpret(r, cpu, status);
}
free(line);
}
bool Equals(const void* pyString) const {
return stringEquals(this, pyString);
}
int runClient(char *port) {
char *name = "Client";
//initialize masterServer, peerList and hostlist
peerList = NULL;
connectionList = NULL;
connectionIdGenerator = 2; //1 is received for the server
masterServer = NULL;
int listernerSockfd = -1;
struct connectionInfo *serverInfo = startServer(port, "CLIENT");
if (serverInfo == NULL) {
fprintf(stderr, "Did not get serverInfo from startServer()\n");
return -1;
}
listernerSockfd = serverInfo->listernerSockfd;
int STDIN = 0; //0 represents STDIN
FD_ZERO(&masterFDList); // clear the master and temp sets
FD_ZERO(&tempFDList);
FD_SET(STDIN, &masterFDList); // add STDIN to master FD list
fdmax = STDIN;
FD_SET(listernerSockfd, &masterFDList); //add the listener to master FD list and update fdmax
if (listernerSockfd > fdmax)
fdmax = listernerSockfd;
int actionComplete = 1;
while (1) //keep waiting for input, connections and data
{
//this is ti identify is an activity is in progress
if (actionComplete == 1) {
printf("$");
fflush(stdout); //print the terminal symbol
}
actionComplete = 1;
tempFDList = masterFDList; //make a copy of masterFDList and use it as select() modifies the list
//int select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
if (select(fdmax + 1, &tempFDList, NULL, NULL, NULL) ==
-1) //select waits till it gets data in an fd in the list
{
fprintf(stderr, "Error in select\n");
return -1;
}
// an FD has data so iterate through the list to find the fd with data
int fd;
for (fd = 0; fd <= 20; fd++) {
if (FD_ISSET(fd, &tempFDList)) //found the FD with data
{
if (fd == STDIN) //data from commandLine(STDIN)
{
size_t commandLength = 50;
char *command = (char *) malloc(commandLength);
getline(&command, &commandLength, stdin); //get line the variable if space is not sufficient
if (stringEquals(command, "\n")) //to handle the stray \n s
continue;
//printf("--Got data: %s--\n",command);
handleCommands(command, "CLIENT");
}
else if (fd == listernerSockfd) //new client trying to connect to listener
{
struct sockaddr_storage clientaddr;
socklen_t addrlen = sizeof clientaddr;
int clientsockfd;
if ((clientsockfd = accept(listernerSockfd, (struct sockaddr *) &clientaddr, &addrlen)) == -1) {
fprintf(stderr, "Error accepting connection: %d %s\n", clientsockfd,
gai_strerror(clientsockfd));
return -1;
}
else {
//accept connection from client add it to the connectionList
struct host *client = (struct host *) malloc(sizeof(struct host));
struct sockaddr *hostAddress = (struct sockaddr *) &clientaddr;
client->id = connectionIdGenerator++;
client->sockfd = clientsockfd;
client->ipAddress = getIPAddress(hostAddress);
client->hostName = getHostFromIp(client->ipAddress);
client->port = getPort(hostAddress);
addNode(&connectionList, client);
FD_SET(client->sockfd, &masterFDList); // add fd to fdlist
if (client->sockfd > fdmax)
fdmax = client->sockfd;
printf("Accepted client: %s/%s.\n", client->hostName, client->port);
}
}
else if (masterServer != NULL && fd == masterServer->sockfd)// handle data from server
{
struct packet *recvPacket = readPacket(fd);
if (recvPacket == NULL) {
printf("Master Server has terminated unexpectedly.\n");
int connectionId = getIDForFD(connectionList, fd);
terminateConnection(connectionId);
masterServer = NULL;
peerList = NULL;
continue;
}
// printf("Received packet: ");
// printPacket(recvPacket);
// printf("\n");
//received terminate from server
if (recvPacket->header->messageType == terminate) {
printf("Received TERMINATE command from server.\n");
int connectionId = getIDForFD(connectionList, fd);
terminateConnection(connectionId);
peerList = NULL;
masterServer = NULL;
continue;
}
if (recvPacket->header->messageType == hostList) {
//split the hostlist
int length = 0;
char **hostinfo = splitString(recvPacket->message, ' ', &length);
free(peerList);
peerList = NULL; //destroy the old peerList
int i;
for (i = 0; i < length; i = i + 2) {
if (i + 1 >= length)
fprintf(stderr, "Disproportionate terms in hostList sent by server.\n");
if (stringEquals(myIpAddress, hostinfo[i]) && stringEquals(myListenerPort, port)) {
//this is so that the client doesn't add itself in the peerList
continue;
}
//add all nodes
struct host *peer = (struct host *) malloc(sizeof(struct host));
peer->sockfd = -1; // we do not have a connection with it yet
peer->ipAddress = hostinfo[i];
peer->hostName = getHostFromIp(peer->ipAddress);
peer->port = hostinfo[i + 1];
addNode(&peerList, peer);
}
printf("New peerList received from server:\n");
printPeerList(peerList);
continue;
}
if (recvPacket->header->messageType == syncFiles) {
printf("Received a sync initiate request from Server.\n");
syncHostnameFiles();
continue;
}
}
else {
//handle data from the peers
struct packet *recvPacket = readPacket(fd);
if (recvPacket == NULL) {
//one of the clients terminated unexpectedly
int id = getIDForFD(connectionList, fd);
struct host *host = getHostByID(connectionList, id);
printf("%s/%s terminated unexpectedly. Removing it from the list.\n",
host->hostName, host->port, host->sockfd);
terminateConnection(id);
continue;
}
// printf("Received packet: ");
// printPacket(recvPacket);
// printf("\n");
//received terminate
if (recvPacket->header->messageType == terminate) {
int id = getIDForFD(connectionList, fd);
struct host *source = getHostByID(connectionList, id);
printf("Received TERMINATE command from %s/%s. Removing it.\n", source->hostName, source->port);
terminateConnection(id);
continue;
}//handle error message
else if (recvPacket->header->messageType == error) {
printf("Received error message: %s\n", recvPacket->message);
continue;
}//handle get request
else if (recvPacket->header->messageType == get) {
int connectionId = getIDForFD(connectionList, fd);
struct host *destination = getHostByID(connectionList, connectionId);
if (destination == NULL) {
fprintf(stderr, "Coudn't find the connection id.\n");
continue;
}
printf("Received a get request for file %s from client: %s/%s.\n",
recvPacket->header->fileName, destination->hostName, destination->port);
sendFile(connectionId, recvPacket->header->fileName);
}//hand a put packet
else if (recvPacket->header->messageType == put) {
int connectionId = getIDForFD(connectionList, fd);
receiveFileAsynchronously(connectionId, recvPacket);
actionComplete = 0; //action is not complete until a ok packet is received
continue;
}//handle a ok packet
else if (recvPacket->header->messageType == ok) {
int connectionId = getIDForFD(connectionList, fd);
okPacketHandler(connectionId, recvPacket);
actionComplete = 1; // activity completed
continue;
}
}
}
}
}
}
PRBool processNextLiteral(RDF_Query q, RDF_Literal literal) {
if (literal->c != NULL) {
RDF_SetVariableValue(literal->variable, RDF_NextValue(literal->c), literal->valueType);
return (RDF_GetVariableValue(literal->variable) != NULL);
} else {
RDF_Resource u; /* unit is a resource except for the comparison case so don't set it yet. */
RDF_Resource s = literal->s;
void* v;
if (literal->variable == NULL) {
PRBool result = false;
PRBool ans = false;
int i;
if (literal->bt) return false;
/* find a value that satisfies predicate */
for (i = 0; i < literal->valueCount; i++) {
TermStruc valueTerm = *(literal->v + i);
if (comparisonp(s)) {
/* unit is a variable in all comparisons.
value may be a variable or a constant.
*/
switch (literal->valueType) {
char *str, *pattern;
int i, j;
case RDF_STRING_TYPE:
if (literal->u.type != RDF_VARIABLE_TERM_TYPE) return false; /* error */
if (((RDF_Variable)literal->u.value)->type != RDF_STRING_TYPE) return false;
str = (char*)RDF_GetVariableValue((RDF_Variable)literal->u.value);
switch (valueTerm.type) {
case RDF_VARIABLE_TERM_TYPE:
pattern = (char*)RDF_GetVariableValue((RDF_Variable)valueTerm.value);
break;
case RDF_CONSTANT_TERM_TYPE:
pattern = (char*)valueTerm.value;
break;
default:
/* should blow up */
return false;
break;
}
if (s == gCoreVocab->RDF_stringEquals) {
ans = stringEquals(pattern, str);
} else if (s == gCoreVocab->RDF_substring) {
ans = substring(pattern, str);
} else if (s == gCoreVocab->RDF_notStringEquals) {
ans = !stringEquals(pattern, str);
} else if (s == gCoreVocab->RDF_notSubstring) {
ans = !substring(pattern, str);
} else return false; /* error */
break;
case RDF_INT_TYPE:
if (literal->u.type != RDF_VARIABLE_TERM_TYPE) return false; /* error */
if (((RDF_Variable)literal->u.value)->type != RDF_INT_TYPE) return false;
i = (int)RDF_GetVariableValue((RDF_Variable)literal->u.value);
switch (valueTerm.type) {
case RDF_VARIABLE_TERM_TYPE:
j = (int)RDF_GetVariableValue((RDF_Variable)valueTerm.value);
break;
case RDF_CONSTANT_TERM_TYPE:
j = (int)valueTerm.value;
break;
default:
/* should blow up */
return false;
break;
}
if (s == gCoreVocab->RDF_equals) {
ans = (i == j);
} else if (s == gCoreVocab->RDF_notEquals) {
ans = (i != j);
} else if (s == gCoreVocab->RDF_lessThan) {
ans = (i < j);
} else if (s == gCoreVocab->RDF_greaterThan) {
ans = (i > j);
} else if (s == gCoreVocab->RDF_lessThanOrEqual) {
ans = (i <= j);
} else if (s == gCoreVocab->RDF_greaterThanOrEqual) {
ans = (i >= j);
} else return false;
break;
default:
return false;
break;
}
}
else {
u = (RDF_Resource)((variableTermp(literal->u)) ? ((RDF_Variable)literal->u.value)->value : literal->u.value);
/* special predicates */
if (s == gCoreVocab->RDF_notInstanceOf) {
ans = !RDF_HasAssertion(q->rdf, u, gCoreVocab->RDF_instanceOf, valueTerm.value, literal->valueType, true);
} else if (s == gCoreVocab->RDF_notParent) {
ans = !RDF_HasAssertion(q->rdf, u, gCoreVocab->RDF_parent, valueTerm.value, literal->valueType, true);
} else ans = RDF_HasAssertion(q->rdf, u, s, valueTerm.value, literal->valueType, true);
}
literal->bt = true;
/* result = ((literal->tv == true) ? ans : !ans); */
result = ans;
if (result) return result; /* otherwise try next value */
}
return result;
}
u = (RDF_Resource)((variableTermp(literal->u)) ? ((RDF_Variable)literal->u.value)->value : literal->u.value);
v = (variableTermp(*literal->v)) ? ((RDF_Variable)literal->v->value)->value : literal->v->value;
if ((u == NULL) && variableTermp(literal->u) && resourceTermp(*literal->v)) {
literal->c = RDF_GetSources(q->rdf, (RDF_Resource)v, s, literal->valueType, true);
if (literal->c == NULL) return false;
RDF_SetVariableValue(literal->variable, RDF_NextValue(literal->c), literal->valueType);
return (RDF_GetVariableValue(literal->variable) != NULL);
} else if ((v == NULL) && variableTermp(*literal->v) && (u != NULL)) {
literal->c = RDF_GetTargets(q->rdf, u, s, literal->valueType, true); /* note arg order differs from java implementation */
if (literal->c == NULL) return false;
RDF_SetVariableValue(literal->variable, RDF_NextValue(literal->c), literal->valueType);
return (RDF_GetVariableValue(literal->variable) != NULL);
} else return false;
}
}
