bool_t giga_rpc_init_1_svc(int rpc_req,
giga_result_t *rpc_reply,
struct svc_req *rqstp)
{
(void)rqstp;
assert(rpc_reply);
logMessage(LOG_TRACE, __func__, "==> RPC_init_recv = %d", rpc_req);
// send bitmap for the "root" directory.
//
int dir_id = 0;
struct giga_directory *dir = cache_fetch(&dir_id);
if (dir == NULL) {
rpc_reply->errnum = -EIO;
logMessage(LOG_DEBUG, __func__, "Dir (id=%d) not in cache!", dir_id);
return true;
}
rpc_reply->errnum = -EAGAIN;
memcpy(&(rpc_reply->giga_result_t_u.bitmap),
&dir->mapping, sizeof(dir->mapping));
logMessage(LOG_TRACE, __func__, "RPC_init_reply(%d)", rpc_reply->errnum);
return true;
}
bool_t giga_rpc_getattr_1_svc(giga_dir_id dir_id, giga_pathname path,
giga_getattr_reply_t *rpc_reply,
struct svc_req *rqstp)
{
(void)rqstp;
assert(rpc_reply);
assert(path);
logMessage(LOG_TRACE, __func__,
"==> RPC_getattr_recv(dir_id=%d,path=%s)", dir_id, path);
bzero(rpc_reply, sizeof(giga_getattr_reply_t));
struct giga_directory *dir = cache_fetch(&dir_id);
if (dir == NULL) {
rpc_reply->result.errnum = -EIO;
logMessage(LOG_DEBUG, __func__, "Dir (id=%d) not in cache!", dir_id);
return true;
}
// (1): get the giga index/partition for operation
int index = giga_get_index_for_file(&dir->mapping, (const char*)path);
int server = giga_get_server_for_index(&dir->mapping, index);
// (2): is this the correct server? NO --> (errnum=-EAGAIN) and return
if (server != giga_options_t.serverID) {
rpc_reply->result.errnum = -EAGAIN;
memcpy(&(rpc_reply->result.giga_result_t_u.bitmap),
&dir->mapping, sizeof(dir->mapping));
logMessage(LOG_TRACE, __func__, "req for server-%d reached server-%d.",
server, giga_options_t.serverID);
return true;
}
char path_name[MAX_LEN];
switch (giga_options_t.backend_type) {
case BACKEND_RPC_LOCALFS:
snprintf(path_name, sizeof(path_name),
"%s/%s", giga_options_t.mountpoint, path);
rpc_reply->result.errnum = local_getattr(path_name,
&rpc_reply->statbuf);
break;
case BACKEND_RPC_LEVELDB:
rpc_reply->result.errnum = leveldb_lookup(ldb_mds,
dir_id, index, path,
&rpc_reply->statbuf);
break;
default:
break;
}
logMessage(LOG_TRACE, __func__, "RPC_getattr_reply");
return true;
}
int fifo_cache::cache_remove(string url)
{
string temp;
if(cache_fetch(url, temp) == 0)
return 0;
size = size - temp.length();
dictionary.erase(url);
fifo_queue.pop();
return 1;
}
int rpc_getattr(int dir_ID, const char *path, struct stat *stbuf)
{
int ret = 0;
int dir_id = dir_ID; // update root server's bitmap
struct giga_directory *dir = cache_fetch(&dir_id);
if (dir == NULL) {
logMessage(LOG_DEBUG, __func__, "Dir (id=%d) not in cache!", dir_id);
ret = -EIO;
}
int server_id = 0;
giga_getattr_reply_t rpc_reply;
retry:
server_id = get_server_for_file(dir, path);
CLIENT *rpc_clnt = getConnection(server_id);
logMessage(LOG_TRACE, __func__, "RPC_getattr: {%s->srv=%d}", path, server_id);
if (giga_rpc_getattr_1(dir_id, (char*)path, &rpc_reply, rpc_clnt)
!= RPC_SUCCESS) {
logMessage(LOG_FATAL, __func__, "RPC_error: rpc_getattr failed.");
clnt_perror(rpc_clnt,"(rpc_getattr failed)");
exit(1);//TODO: retry again?
}
int errnum = rpc_reply.result.errnum;
if (errnum == -EAGAIN) {
update_client_mapping(dir, &rpc_reply.result.giga_result_t_u.bitmap);
goto retry;
} else if (errnum < 0) {
ret = errnum;
} else {
*stbuf = rpc_reply.statbuf;
if (stbuf == NULL)
logMessage(LOG_DEBUG, __func__, "getattr() stbuf is NULL!");
ret = errnum;
}
logMessage(LOG_TRACE, __func__, "RPC_getattr: STATUS={%s}", strerror(ret));
return ret;
}
/** Updates parent_ref to point to the specified child */
static int lookup(PVFS_credentials *credentails, PVFS_object_ref* ref, char* pathname)
{
int ret = 0, server_id;
enum clnt_stat retval;
skye_lookup result;
if (strlen(pathname) >= MAX_FILENAME_LEN)
return -ENAMETOOLONG;
struct skye_directory *dir = cache_fetch(ref);
if (!dir)
return -EIO;
bitmap:
server_id = get_server_for_file(dir, pathname);
CLIENT *rpc_client = get_connection(server_id);
retval = skye_rpc_lookup_1(*credentails, *ref, pathname, &result, rpc_client);
if (retval != RPC_SUCCESS) {
clnt_perror (rpc_client, "RPC lookup failed");
ret = -EIO;
goto exit;
}
if (result.errnum == -EAGAIN){
update_client_mapping(dir, &result.skye_lookup_u.bitmap);
goto bitmap;
} else if (result.errnum < 0){
ret = result.errnum;
goto exit;
} else {
ret = 0;
}
/* Giga+: Add a section here for reading out the bitmap */
memcpy(ref, &result.skye_lookup_u.ref, sizeof(PVFS_object_ref));
exit:
cache_return(dir);
return ret;
}
int rpc_init()
{
int ret = 0;
int server_id = 0;
CLIENT *rpc_clnt = getConnection(server_id);
giga_result_t rpc_reply;
logMessage(LOG_TRACE, __func__, "RPC_init: start.");
if ((giga_rpc_init_1(giga_options_t.num_servers, &rpc_reply, rpc_clnt))
!= RPC_SUCCESS) {
logMessage(LOG_FATAL, __func__, "RPC_error: rpc_init failed.");
clnt_perror(rpc_clnt,"(rpc_init failed)");
exit(1);//TODO: retry again?
}
int errnum = rpc_reply.errnum;
if (errnum == -EAGAIN) {
int dir_id = 0; // update root server's bitmap
struct giga_directory *dir = cache_fetch(&dir_id);
if (dir == NULL) {
logMessage(LOG_DEBUG, __func__, "Dir (id=%d) not in cache!", dir_id);
ret = -EIO;
}
else {
update_client_mapping(dir, &rpc_reply.giga_result_t_u.bitmap);
ret = 0;
}
} else if (errnum < 0) {
ret = errnum;
}
logMessage(LOG_TRACE, __func__, "RPC_init: done.");
return ret;
}
/* ret= 0! if action -> end of list(e.g DROP),
> 0 to continue processing next actions
and <0 on error */
int do_action(struct action* a, struct sip_msg* msg)
{
int ret;
int v;
int sec,usec;
union sockaddr_union* to;
struct proxy_l* p;
char* tmp;
char *new_uri, *end, *crt;
int len,i;
int user;
str vals[5];
str result;
struct sip_uri uri, next_hop;
struct sip_uri *u;
unsigned short port;
int cmatch;
struct action *aitem;
struct action *adefault;
pv_spec_t *spec;
pv_elem_p model;
pv_value_t val;
pv_elem_t *pve;
str name_s;
/* reset the value of error to E_UNSPEC so avoid unknowledgable
functions to return with error (status<0) and not setting it
leaving there previous error; cache the previous value though
for functions which want to process it */
prev_ser_error=ser_error;
ser_error=E_UNSPEC;
ret=E_BUG;
switch ((unsigned char)a->type){
case DROP_T:
action_flags |= ACT_FL_DROP;
case EXIT_T:
ret=0;
action_flags |= ACT_FL_EXIT;
break;
case RETURN_T:
if (a->elem[0].type == SCRIPTVAR_ST)
{
spec = (pv_spec_t*)a->elem[0].u.data;
if(pv_get_spec_value(msg, spec, &val)!=0
|| (val.flags&PV_VAL_NULL))
{
ret=-1;
} else {
if(!(val.flags&PV_VAL_INT))
ret = 1;
else
ret = val.ri;
}
pv_value_destroy(&val);
} else {
ret=a->elem[0].u.number;
}
action_flags |= ACT_FL_RETURN;
break;
case FORWARD_T:
if (a->elem[0].type==NOSUBTYPE){
/* parse uri and build a proxy */
if (msg->dst_uri.len) {
ret = parse_uri(msg->dst_uri.s, msg->dst_uri.len,
&next_hop);
u = &next_hop;
} else {
ret = parse_sip_msg_uri(msg);
u = &msg->parsed_uri;
}
if (ret<0) {
LM_ERR("forward: bad_uri dropping packet\n");
break;
}
/* create a temporary proxy*/
p=mk_proxy(u->maddr_val.len?&u->maddr_val:&u->host,
u->port_no, u->proto, (u->type==SIPS_URI_T)?1:0 );
if (p==0){
LM_ERR("bad host name in uri, dropping packet\n");
ret=E_BAD_ADDRESS;
goto error_fwd_uri;
}
ret=forward_request(msg, p);
free_proxy(p); /* frees only p content, not p itself */
pkg_free(p);
if (ret==0) ret=1;
}else if ((a->elem[0].type==PROXY_ST)) {
ret=forward_request(msg,(struct proxy_l*)a->elem[0].u.data);
if (ret==0) ret=1;
}else{
LM_ALERT("BUG in forward() types %d, %d\n",
a->elem[0].type, a->elem[1].type);
ret=E_BUG;
}
break;
case SEND_T:
if (a->elem[0].type!= PROXY_ST){
LM_ALERT("BUG in send() type %d\n", a->elem[0].type);
ret=E_BUG;
break;
}
to=(union sockaddr_union*)
pkg_malloc(sizeof(union sockaddr_union));
if (to==0){
LM_ERR("memory allocation failure\n");
ret=E_OUT_OF_MEM;
break;
}
p=(struct proxy_l*)a->elem[0].u.data;
ret=hostent2su(to, &p->host, p->addr_idx,
(p->port)?p->port:SIP_PORT );
if (ret==0){
ret = msg_send(0/*send_sock*/, p->proto, to, 0/*id*/,
msg->buf, msg->len);
if (ret!=0 && p->host.h_addr_list[p->addr_idx+1])
p->addr_idx++;
}
pkg_free(to);
if (ret==0)
ret=1;
break;
case LOG_T:
if ((a->elem[0].type!=NUMBER_ST)|(a->elem[1].type!=STRING_ST)){
LM_ALERT("BUG in log() types %d, %d\n",
a->elem[0].type, a->elem[1].type);
ret=E_BUG;
break;
}
LM_GEN1(a->elem[0].u.number, "%s", a->elem[1].u.string);
ret=1;
break;
case APPEND_BRANCH_T:
if ((a->elem[0].type!=STR_ST)) {
LM_ALERT("BUG in append_branch %d\n",
a->elem[0].type );
ret=E_BUG;
break;
}
if (a->elem[0].u.s.s==NULL) {
ret = append_branch(msg, 0, &msg->dst_uri, &msg->path_vec,
get_ruri_q(), getb0flags(), msg->force_send_socket);
/* reset all branch info */
msg->force_send_socket = 0;
setb0flags(0);
set_ruri_q(Q_UNSPECIFIED);
if(msg->dst_uri.s!=0)
pkg_free(msg->dst_uri.s);
msg->dst_uri.s = 0;
msg->dst_uri.len = 0;
if(msg->path_vec.s!=0)
pkg_free(msg->path_vec.s);
msg->path_vec.s = 0;
msg->path_vec.len = 0;
} else {
ret = append_branch(msg, &a->elem[0].u.s, &msg->dst_uri,
&msg->path_vec, a->elem[1].u.number, getb0flags(),
msg->force_send_socket);
}
break;
case REMOVE_BRANCH_T:
if (a->elem[0].type == SCRIPTVAR_ST) {
spec = (pv_spec_t*)a->elem[0].u.data;
if( pv_get_spec_value(msg, spec, &val)!=0
|| (val.flags&PV_VAL_NULL) || !(val.flags&PV_VAL_INT) ) {
ret=-1;
break;
}
i = val.ri;
} else {
i=a->elem[0].u.number;
}
ret = (remove_branch((unsigned int)i)==0)?1:-1;
break;
case LEN_GT_T:
if (a->elem[0].type!=NUMBER_ST) {
LM_ALERT("BUG in len_gt type %d\n",
a->elem[0].type );
ret=E_BUG;
break;
}
ret = (msg->len >= (unsigned int)a->elem[0].u.number) ? 1 : -1;
break;
case SET_DEBUG_T:
if (a->elem[0].type==NUMBER_ST)
set_proc_debug_level(a->elem[0].u.number);
else
reset_proc_debug_level();
ret = 1;
break;
case SETFLAG_T:
ret = setflag( msg, a->elem[0].u.number );
break;
case RESETFLAG_T:
ret = resetflag( msg, a->elem[0].u.number );
break;
case ISFLAGSET_T:
ret = isflagset( msg, a->elem[0].u.number );
break;
case SETSFLAG_T:
ret = setsflag( a->elem[0].u.number );
break;
case RESETSFLAG_T:
ret = resetsflag( a->elem[0].u.number );
break;
case ISSFLAGSET_T:
ret = issflagset( a->elem[0].u.number );
break;
case SETBFLAG_T:
ret = setbflag( a->elem[0].u.number, a->elem[1].u.number );
break;
case RESETBFLAG_T:
ret = resetbflag( a->elem[0].u.number, a->elem[1].u.number );
break;
case ISBFLAGSET_T:
ret = isbflagset( a->elem[0].u.number, a->elem[1].u.number );
break;
case ERROR_T:
if ((a->elem[0].type!=STRING_ST)|(a->elem[1].type!=STRING_ST)){
LM_ALERT("BUG in error() types %d, %d\n",
a->elem[0].type, a->elem[1].type);
ret=E_BUG;
break;
}
LM_ERR("error(\"%s\", \"%s\") not implemented yet\n",
a->elem[0].u.string, a->elem[1].u.string);
ret=1;
break;
case ROUTE_T:
if (a->elem[0].type!=NUMBER_ST){
LM_ALERT("BUG in route() type %d\n",
a->elem[0].type);
ret=E_BUG;
break;
}
if ((a->elem[0].u.number>RT_NO)||(a->elem[0].u.number<0)){
LM_ALERT("BUG - invalid routing table number in"
"route(%lu)\n", a->elem[0].u.number);
ret=E_CFG;
break;
}
return_code=run_actions(rlist[a->elem[0].u.number].a, msg);
ret=return_code;
break;
case REVERT_URI_T:
if (msg->new_uri.s) {
pkg_free(msg->new_uri.s);
msg->new_uri.len=0;
msg->new_uri.s=0;
msg->parsed_uri_ok=0; /* invalidate current parsed uri*/
};
ret=1;
break;
case SET_HOST_T:
case SET_HOSTPORT_T:
case SET_USER_T:
case SET_USERPASS_T:
case SET_PORT_T:
case SET_URI_T:
case PREFIX_T:
case STRIP_T:
case STRIP_TAIL_T:
user=0;
if (a->type==STRIP_T || a->type==STRIP_TAIL_T) {
if (a->elem[0].type!=NUMBER_ST) {
LM_ALERT("BUG in set*() type %d\n",
a->elem[0].type);
break;
}
} else if (a->elem[0].type!=STR_ST){
LM_ALERT("BUG in set*() type %d\n",
a->elem[0].type);
ret=E_BUG;
break;
}
if (a->type==SET_URI_T) {
if (set_ruri( msg, &a->elem[0].u.s) ) {
LM_ERR("failed to set new RURI\n");
ret=E_OUT_OF_MEM;
break;
}
ret=1;
break;
}
if (msg->new_uri.s) {
tmp=msg->new_uri.s;
len=msg->new_uri.len;
}else{
tmp=msg->first_line.u.request.uri.s;
len=msg->first_line.u.request.uri.len;
}
if (parse_uri(tmp, len, &uri)<0){
LM_ERR("bad uri <%.*s>, dropping packet\n", len, tmp);
ret=E_UNSPEC;
break;
}
new_uri=pkg_malloc(MAX_URI_SIZE);
if (new_uri==0){
LM_ERR("memory allocation failure\n");
ret=E_OUT_OF_MEM;
break;
}
end=new_uri+MAX_URI_SIZE;
crt=new_uri;
/* begin copying */
len = (uri.user.len?uri.user.s:uri.host.s) - tmp;
if (crt+len>end) goto error_uri;
memcpy(crt,tmp,len);crt+=len;
if (a->type==PREFIX_T) {
if (crt+a->elem[0].u.s.len>end) goto error_uri;
memcpy( crt, a->elem[0].u.s.s, a->elem[0].u.s.len);
crt+=a->elem[0].u.s.len;
/* whatever we had before, with prefix we have username
now */
user=1;
}
if ((a->type==SET_USER_T)||(a->type==SET_USERPASS_T)) {
tmp=a->elem[0].u.s.s;
len=a->elem[0].u.s.len;
} else if (a->type==STRIP_T) {
if (a->elem[0].u.number>uri.user.len) {
LM_WARN("too long strip asked; "
" deleting username: %lu of <%.*s>\n",
a->elem[0].u.number, uri.user.len, uri.user.s);
len=0;
} else if (a->elem[0].u.number==uri.user.len) {
len=0;
} else {
tmp=uri.user.s + a->elem[0].u.number;
len=uri.user.len - a->elem[0].u.number;
}
} else if (a->type==STRIP_TAIL_T) {
if (a->elem[0].u.number>uri.user.len) {
LM_WARN("too long strip_tail asked;"
" deleting username: %lu of <%.*s>\n",
a->elem[0].u.number, uri.user.len, uri.user.s);
len=0;
} else if (a->elem[0].u.number==uri.user.len) {
len=0;
} else {
tmp=uri.user.s;
len=uri.user.len - a->elem[0].u.number;
}
} else {
tmp=uri.user.s;
len=uri.user.len;
}
if (len){
if(crt+len>end) goto error_uri;
memcpy(crt,tmp,len);crt+=len;
user=1; /* we have an user field so mark it */
}
if (a->type==SET_USERPASS_T) tmp=0;
else tmp=uri.passwd.s;
/* passwd */
if (tmp){
len=uri.passwd.len; if(crt+len+1>end) goto error_uri;
*crt=':'; crt++;
memcpy(crt,tmp,len);crt+=len;
}
/* host */
if (user || tmp){ /* add @ */
if(crt+1>end) goto error_uri;
*crt='@'; crt++;
}
if ((a->type==SET_HOST_T) ||(a->type==SET_HOSTPORT_T)) {
tmp=a->elem[0].u.s.s;
len=a->elem[0].u.s.len;
} else {
tmp=uri.host.s;
len = uri.host.len;
}
if (tmp){
if(crt+len>end) goto error_uri;
memcpy(crt,tmp,len);crt+=len;
}
/* port */
if (a->type==SET_HOSTPORT_T) tmp=0;
else if (a->type==SET_PORT_T) {
tmp=a->elem[0].u.s.s;
len=a->elem[0].u.s.len;
} else {
tmp=uri.port.s;
len = uri.port.len;
}
if (tmp && len>0){
if(crt+len+1>end) goto error_uri;
*crt=':'; crt++;
memcpy(crt,tmp,len);crt+=len;
}
/* params */
tmp=uri.params.s;
if (tmp){
/* include in param string the starting ';' */
len=uri.params.len+1;
tmp--;
if(crt+len+1>end) goto error_uri;
/* if a maddr param is present, strip it out */
if (uri.maddr.len &&
(a->type==SET_HOSTPORT_T || a->type==SET_HOST_T)) {
memcpy(crt,tmp,uri.maddr.s-tmp-1);
crt+=uri.maddr.s-tmp-1;
memcpy(crt,uri.maddr_val.s+uri.maddr_val.len,
tmp+len-uri.maddr_val.s-uri.maddr_val.len);
crt+=tmp+len-uri.maddr_val.s-uri.maddr_val.len;
} else {
memcpy(crt,tmp,len);crt+=len;
}
}
/* headers */
tmp=uri.headers.s;
if (tmp){
len=uri.headers.len; if(crt+len+1>end) goto error_uri;
*crt='?'; crt++;
memcpy(crt,tmp,len);crt+=len;
}
*crt=0; /* null terminate the thing */
/* copy it to the msg */
if (msg->new_uri.s) pkg_free(msg->new_uri.s);
msg->new_uri.s=new_uri;
msg->new_uri.len=crt-new_uri;
msg->parsed_uri_ok=0;
ret=1;
break;
case SET_DSTURI_T:
if (a->elem[0].type!=STR_ST){
LM_ALERT("BUG in setdsturi() type %d\n",
a->elem[0].type);
ret=E_BUG;
break;
}
if(set_dst_uri(msg, &a->elem[0].u.s)!=0)
ret = -1;
else
ret = 1;
break;
case SET_DSTHOST_T:
case SET_DSTPORT_T:
if (a->elem[0].type!=STR_ST){
LM_ALERT("BUG in domain setting type %d\n",
a->elem[0].type);
ret=E_BUG;
break;
}
tmp = msg->dst_uri.s;
len = msg->dst_uri.len;
if (tmp == NULL || len == 0) {
LM_ERR("failure - null uri\n");
ret = E_UNSPEC;
break;
}
if (a->type == SET_DSTHOST_T &&
(a->elem[0].u.s.s == NULL || a->elem[0].u.s.len == 0)) {
LM_ERR("cannot set a null uri domain\n");
break;
}
if (parse_uri(tmp, len, &uri)<0) {
LM_ERR("bad uri <%.*s>, dropping packet\n", len, tmp);
break;
}
new_uri=pkg_malloc(MAX_URI_SIZE);
if (new_uri == NULL) {
LM_ERR("memory allocation failure\n");
ret=E_OUT_OF_MEM;
break;
}
end=new_uri+MAX_URI_SIZE;
crt=new_uri;
len = (uri.user.len?uri.user.s:uri.host.s) - tmp;
if (crt+len>end) goto error_uri;
memcpy(crt,tmp,len);
crt += len;
/* user */
tmp = uri.user.s;
len = uri.user.len;
if (tmp) {
if (crt+len>end) goto error_uri;
memcpy(crt,tmp,len);
crt += len;
user = 1;
}
/* passwd */
tmp = uri.passwd.s;
len = uri.passwd.len;
if (user || tmp) {
if (crt+len+1>end) goto error_uri;
*crt++=':';
memcpy(crt, tmp, len);
crt += len;
}
/* host */
if (a->type==SET_DSTHOST_T) {
tmp = a->elem[0].u.s.s;
len = a->elem[0].u.s.len;
} else {
tmp = uri.host.s;
len = uri.host.len;
}
if (tmp) {
if (user) {
if (crt+1>end) goto error_uri;
*crt++='@';
}
if (crt+len+1>end) goto error_uri;
memcpy(crt, tmp, len);
crt += len;
}
/* port */
if (a->type==SET_DSTPORT_T) {
tmp = a->elem[0].u.s.s;
len = a->elem[0].u.s.len;
} else {
tmp = uri.port.s;
len = uri.port.len;
}
if (tmp) {
if (crt+len+1>end) goto error_uri;
*crt++=':';
memcpy(crt, tmp, len);
crt += len;
}
/* params */
tmp=uri.params.s;
if (tmp){
len=uri.params.len; if(crt+len+1>end) goto error_uri;
*crt++=';';
memcpy(crt,tmp,len);
crt += len;
}
/* headers */
tmp=uri.headers.s;
if (tmp){
len=uri.headers.len; if(crt+len+1>end) goto error_uri;
*crt++='?';
memcpy(crt,tmp,len);
crt += len;
}
*crt=0; /* null terminate the thing */
/* copy it to the msg */
pkg_free(msg->dst_uri.s);
msg->dst_uri.s=new_uri;
msg->dst_uri.len=crt-new_uri;
ret = 1;
break;
case RESET_DSTURI_T:
if(msg->dst_uri.s!=0)
pkg_free(msg->dst_uri.s);
msg->dst_uri.s = 0;
msg->dst_uri.len = 0;
ret = 1;
break;
case ISDSTURISET_T:
if(msg->dst_uri.s==0 || msg->dst_uri.len<=0)
ret = -1;
else
ret = 1;
break;
case IF_T:
/* if null expr => ignore if? */
if ((a->elem[0].type==EXPR_ST)&&a->elem[0].u.data){
v=eval_expr((struct expr*)a->elem[0].u.data, msg, 0);
/* set return code to expr value */
if (v<0 || (action_flags&ACT_FL_RETURN)
|| (action_flags&ACT_FL_EXIT) ){
if (v==EXPR_DROP || (action_flags&ACT_FL_RETURN)
|| (action_flags&ACT_FL_EXIT) ){ /* hack to quit on DROP*/
ret=0;
return_code = 0;
break;
}else{
LM_WARN("error in expression (l=%d)\n", a->line);
}
}
ret=1; /*default is continue */
if (v>0) {
if ((a->elem[1].type==ACTIONS_ST)&&a->elem[1].u.data){
ret=run_action_list(
(struct action*)a->elem[1].u.data,msg );
return_code = ret;
} else return_code = v;
}else{
if ((a->elem[2].type==ACTIONS_ST)&&a->elem[2].u.data){
ret=run_action_list(
(struct action*)a->elem[2].u.data,msg);
return_code = ret;
} else return_code = v;
}
}
break;
case WHILE_T:
/* if null expr => ignore if? */
if ((a->elem[0].type==EXPR_ST)&&a->elem[0].u.data){
len = 0;
while(1)
{
if(len++ >= max_while_loops)
{
LM_INFO("max while loops are encountered\n");
break;
}
v=eval_expr((struct expr*)a->elem[0].u.data, msg, 0);
/* set return code to expr value */
if (v<0 || (action_flags&ACT_FL_RETURN)
|| (action_flags&ACT_FL_EXIT) ){
if (v==EXPR_DROP || (action_flags&ACT_FL_RETURN)
|| (action_flags&ACT_FL_EXIT) ){
ret=0;
return_code = 0;
break;
}else{
LM_WARN("error in expression (l=%d)\n",
a->line);
}
}
ret=1; /*default is continue */
if (v>0) {
if ((a->elem[1].type==ACTIONS_ST)
&&a->elem[1].u.data){
ret=run_action_list(
(struct action*)a->elem[1].u.data,msg );
/* check if return was done */
if ((action_flags&ACT_FL_RETURN)
|| (action_flags&ACT_FL_EXIT) ){
break;
}
return_code = ret;
} else {
/* we should not get here */
return_code = v;
break;
}
} else {
/* condition was false */
return_code = v;
break;
}
}
}
break;
case CACHE_STORE_T:
if ((a->elem[0].type!=STR_ST)) {
LM_ALERT("BUG in cache_store() - first argument not of"
" type string [%d]\n",
a->elem[0].type );
ret=E_BUG;
break;
}
if ((a->elem[1].type!=STR_ST)) {
LM_ALERT("BUG in cache_store() - second argument not of "
"type string [%d]\n", a->elem[1].type );
ret=E_BUG;
break;
}
if ((a->elem[2].type!=STR_ST)) {
LM_ALERT("BUG in cache_store() - third argument not of type"
" string%d\n", a->elem[2].type );
ret=E_BUG;
break;
}
str val_s;
int expires = 0;
/* parse the name argument */
pve = (pv_elem_t *)a->elem[1].u.data;
if ( pv_printf_s(msg, pve, &name_s)!=0 ||
name_s.len == 0 || name_s.s == NULL) {
LM_WARN("cannot get string for value\n");
ret=E_BUG;
break;
}
/* parse the value argument */
pve = (pv_elem_t *)a->elem[2].u.data;
if ( pv_printf_s(msg, pve, &val_s)!=0 ||
val_s.len == 0 || val_s.s == NULL) {
LM_WARN("cannot get string for value\n");
ret=E_BUG;
break;
}
/* get the expires value */
if ( a->elem[3].type == SCRIPTVAR_ST )
{
spec = (pv_spec_t*)a->elem[3].u.data;
memset(&val, 0, sizeof(pv_value_t));
if(pv_get_spec_value(msg, spec, &val) < 0)
{
LM_DBG("Failed to get scriptvar value while executing cache_store\n");
ret=E_BUG;
break;
}
if (!(val.flags&PV_VAL_INT))
{
LM_ERR("Wrong value for cache_store expires, not an integer [%.*s]\n",
val.rs.len, val.rs.s);
}
expires = val.ri;
}
else
if ( a->elem[3].type == NUMBER_ST )
{
expires = (int)a->elem[3].u.number;
}
ret = cache_store( &a->elem[0].u.s, &name_s, &val_s, expires);
break;
case CACHE_REMOVE_T:
if ((a->elem[0].type!=STR_ST)) {
LM_ALERT("BUG in cache_remove() %d\n",
a->elem[0].type );
ret=E_BUG;
break;
}
if ((a->elem[1].type!=STR_ST)) {
LM_ALERT("BUG in cache_remove() %d\n",
a->elem[1].type );
ret=E_BUG;
break;
}
/* parse the name argument */
pve = (pv_elem_t *)a->elem[1].u.data;
if ( pv_printf_s(msg, pve, &name_s)!=0 ||
name_s.len == 0 || name_s.s == NULL) {
LM_WARN("cannot get string for value\n");
ret=E_BUG;
break;
}
ret = cache_remove( &a->elem[0].u.s, &name_s);
break;
case CACHE_FETCH_T:
if ((a->elem[0].type!=STR_ST)) {
LM_ALERT("BUG in cache_fetch() %d\n",
a->elem[0].type );
ret=E_BUG;
break;
}
if ((a->elem[1].type!=STR_ST)) {
LM_ALERT("BUG in cache_fetch() %d\n",
a->elem[1].type );
ret=E_BUG;
break;
}
if (a->elem[2].type!=SCRIPTVAR_ST){
LM_ALERT("BUG in cache_fetch() type %d\n",
a->elem[2].type);
ret=E_BUG;
break;
}
str aux = {0, 0};
/* parse the name argument */
pve = (pv_elem_t *)a->elem[1].u.data;
if ( pv_printf_s(msg, pve, &name_s)!=0 ||
name_s.len == 0 || name_s.s == NULL) {
LM_WARN("cannot get string for value\n");
ret=E_BUG;
break;
}
ret = cache_fetch( &a->elem[0].u.s, &name_s, &aux);
if(ret > 0)
{
int_str res;
int avp_name;
unsigned short avp_type;
spec = (pv_spec_t*)a->elem[2].u.data;
if (pv_get_avp_name( msg, &(spec->pvp), &avp_name,
&avp_type)!=0){
LM_CRIT("BUG in getting AVP name\n");
pkg_free(aux.s);
return -1;
}
res.s = aux;
if (add_avp(AVP_VAL_STR|avp_type, avp_name, res)<0){
LM_ERR("cannot add AVP\n");
pkg_free(aux.s);
return -1;
}
pkg_free(aux.s);
}
break;
case XDBG_T:
if (a->elem[0].type == SCRIPTVAR_ELEM_ST)
{
if (xdbg(msg, a->elem[0].u.data, val.rs.s) < 0)
{
LM_ALERT("Cannot print message");
break;
}
}
else
{
LM_ALERT("BUG in xdbg() type %d\n", a->elem[0].type);
ret=E_BUG;
}
break;
case XLOG_T:
if (a->elem[1].u.data != NULL)
{
if (a->elem[1].type != SCRIPTVAR_ELEM_ST)
{
LM_ALERT("BUG in xlog() type %d\n", a->elem[1].type);
ret=E_BUG;
break;
}
if (a->elem[0].type != STR_ST)
{
LM_ALERT("BUG in xlog() type %d\n", a->elem[0].type);
ret=E_BUG;
break;
}
if (xlog_2(msg,a->elem[0].u.data, a->elem[1].u.data) < 0)
{
LM_ALERT("Cannot print xlog debug message");
break;
}
}
else
{
if (a->elem[0].type != SCRIPTVAR_ELEM_ST)
{
LM_ALERT("BUG in xlog() type %d\n", a->elem[0].type);
ret=E_BUG;
break;
}
if (xlog_1(msg,a->elem[0].u.data, val.rs.s) < 0)
{
LM_ALERT("Cannot print xlog debug message");
break;
}
}
break;
case RAISE_EVENT_T:
if (a->elem[0].type != NUMBER_ST) {
LM_ERR("invalid event id\n");
ret=E_BUG;
break;
}
if (a->elem[2].u.data) {
/* three parameters specified */
ret = evi_raise_script_event((event_id_t)a->elem[0].u.number,
a->elem[1].u.data, a->elem[2].u.data);
} else {
/* two parameters specified */
ret = evi_raise_script_event((event_id_t)a->elem[0].u.number,
NULL, a->elem[1].u.data);
}
if (ret <= 0) {
LM_ERR("cannot raise event\n");
ret=E_UNSPEC;
break;
}
break;
case CONSTRUCT_URI_T:
for (i=0;i<5;i++)
{
pve = (pv_elem_t *)a->elem[i].u.data;
if (pve->spec.getf)
{
if ( pv_printf_s(msg, pve, &vals[i])!=0 ||
vals[i].len == 0 || vals[i].s == NULL)
{
LM_WARN("cannot get string for value\n");
ret=E_BUG;
return -1;
}
}
else
vals[i] = pve->text;
}
result.s = construct_uri(&vals[0],&vals[1],&vals[2],&vals[3],&vals[4],
&result.len);
if (result.s)
{
int_str res;
int avp_name;
unsigned short avp_type;
spec = (pv_spec_t*)a->elem[5].u.data;
if (pv_get_avp_name( msg, &(spec->pvp), &avp_name,
&avp_type)!=0){
LM_CRIT("BUG in getting AVP name\n");
return -1;
}
res.s = result;
if (add_avp(AVP_VAL_STR|avp_type, avp_name, res)<0){
LM_ERR("cannot add AVP\n");
return -1;
}
}
break;
case GET_TIMESTAMP_T:
if (get_timestamp(&sec,&usec) == 0) {
int avp_name;
int_str res;
unsigned short avp_type;
spec = (pv_spec_t*)a->elem[0].u.data;
if (pv_get_avp_name(msg, &(spec->pvp), &avp_name,
&avp_type) != 0) {
LM_CRIT("BUG in getting AVP name\n");
return -1;
}
res.n = sec;
if (add_avp(avp_type, avp_name, res) < 0) {
LM_ERR("cannot add AVP\n");
return -1;
}
spec = (pv_spec_t*)a->elem[1].u.data;
if (pv_get_avp_name(msg, &(spec->pvp), &avp_name,
&avp_type) != 0) {
LM_CRIT("BUG in getting AVP name\n");
return -1;
}
res.n = usec;
if (add_avp(avp_type, avp_name, res) < 0) {
LM_ERR("cannot add AVP\n");
return -1;
}
} else {
LM_ERR("failed to get time\n");
return -1;
}
break;
case SWITCH_T:
if (a->elem[0].type!=SCRIPTVAR_ST){
LM_ALERT("BUG in switch() type %d\n",
a->elem[0].type);
ret=E_BUG;
break;
}
spec = (pv_spec_t*)a->elem[0].u.data;
if(pv_get_spec_value(msg, spec, &val)!=0)
{
LM_ALERT("BUG - no value in switch()\n");
ret=E_BUG;
break;
}
/* get the value of pvar */
if(a->elem[1].type!=ACTIONS_ST) {
LM_ALERT("BUG in switch() actions\n");
ret=E_BUG;
break;
}
return_code=1;
adefault = NULL;
aitem = (struct action*)a->elem[1].u.data;
cmatch=0;
while(aitem)
{
if((unsigned char)aitem->type==DEFAULT_T)
adefault=aitem;
if(cmatch==0)
{
if(aitem->elem[0].type==STR_ST)
{
if(val.flags&PV_VAL_STR
&& val.rs.len==aitem->elem[0].u.s.len
&& strncasecmp(val.rs.s, aitem->elem[0].u.s.s,
val.rs.len)==0)
cmatch = 1;
} else { /* number */
if(val.flags&PV_VAL_INT &&
val.ri==aitem->elem[0].u.number)
cmatch = 1;
}
}
if(cmatch==1)
{
if(aitem->elem[1].u.data)
{
return_code=run_action_list(
(struct action*)aitem->elem[1].u.data, msg);
if ((action_flags&ACT_FL_RETURN) ||
(action_flags&ACT_FL_EXIT))
break;
}
if(aitem->elem[2].u.number==1)
break;
}
aitem = aitem->next;
}
if((cmatch==0) && (adefault!=NULL))
{
LM_DBG("switch: running default statement\n");
if(adefault->elem[0].u.data)
return_code=run_action_list(
(struct action*)adefault->elem[0].u.data, msg);
}
ret=return_code;
break;
case MODULE_T:
if ( (a->elem[0].type==CMD_ST) && a->elem[0].u.data ) {
ret=((cmd_export_t*)(a->elem[0].u.data))->function(msg,
(char*)a->elem[1].u.data, (char*)a->elem[2].u.data,
(char*)a->elem[3].u.data, (char*)a->elem[4].u.data,
(char*)a->elem[5].u.data, (char*)a->elem[6].u.data);
}else{
LM_ALERT("BUG in module call\n");
}
break;
case FORCE_RPORT_T:
msg->msg_flags|=FL_FORCE_RPORT;
ret=1; /* continue processing */
break;
case FORCE_LOCAL_RPORT_T:
msg->msg_flags|=FL_FORCE_LOCAL_RPORT;
ret=1; /* continue processing */
break;
case SET_ADV_ADDR_T:
if (a->elem[0].type!=STR_ST){
LM_ALERT("BUG in set_advertised_address() "
"type %d\n", a->elem[0].type);
ret=E_BUG;
break;
}
msg->set_global_address=*((str*)a->elem[0].u.data);
ret=1; /* continue processing */
break;
case SET_ADV_PORT_T:
if (a->elem[0].type!=STR_ST){
LM_ALERT("BUG in set_advertised_port() "
"type %d\n", a->elem[0].type);
ret=E_BUG;
break;
}
msg->set_global_port=*((str*)a->elem[0].u.data);
ret=1; /* continue processing */
break;
#ifdef USE_TCP
case FORCE_TCP_ALIAS_T:
if ( msg->rcv.proto==PROTO_TCP
#ifdef USE_TLS
|| msg->rcv.proto==PROTO_TLS
#endif
){
if (a->elem[0].type==NOSUBTYPE) port=msg->via1->port;
else if (a->elem[0].type==NUMBER_ST)
port=(int)a->elem[0].u.number;
else{
LM_ALERT("BUG in force_tcp_alias"
" port type %d\n", a->elem[0].type);
ret=E_BUG;
break;
}
if (tcpconn_add_alias(msg->rcv.proto_reserved1, port,
msg->rcv.proto)!=0){
LM_ERR("tcp alias failed\n");
ret=E_UNSPEC;
break;
}
}
#endif
ret=1; /* continue processing */
break;
case FORCE_SEND_SOCKET_T:
if (a->elem[0].type!=SOCKETINFO_ST){
LM_ALERT("BUG in force_send_socket argument"
" type: %d\n", a->elem[0].type);
ret=E_BUG;
break;
}
msg->force_send_socket=(struct socket_info*)a->elem[0].u.data;
ret=1; /* continue processing */
break;
case SERIALIZE_BRANCHES_T:
if (a->elem[0].type!=NUMBER_ST){
LM_ALERT("BUG in serialize_branches argument"
" type: %d\n", a->elem[0].type);
ret=E_BUG;
break;
}
if (serialize_branches(msg,(int)a->elem[0].u.number)!=0) {
LM_ERR("serialize_branches failed\n");
ret=E_UNSPEC;
break;
}
ret=1; /* continue processing */
break;
case NEXT_BRANCHES_T:
if ((ret=next_branches(msg))<0) {
LM_ERR("next_branches failed\n");
ret=E_UNSPEC;
break;
}
/* continue processing */
break;
case EQ_T:
case COLONEQ_T:
case PLUSEQ_T:
case MINUSEQ_T:
case DIVEQ_T:
case MULTEQ_T:
case MODULOEQ_T:
case BANDEQ_T:
case BOREQ_T:
case BXOREQ_T:
ret = do_assign(msg, a);
break;
case USE_BLACKLIST_T:
mark_for_search((struct bl_head*)a->elem[0].u.data, 1);
break;
case UNUSE_BLACKLIST_T:
mark_for_search((struct bl_head*)a->elem[0].u.data, 0);
break;
case PV_PRINTF_T:
ret = -1;
spec = (pv_spec_p)a->elem[0].u.data;
if(!pv_is_w(spec))
{
LM_ERR("read only PV in first parameter of pv_printf\n");
goto error;
}
model = (pv_elem_p)a->elem[1].u.data;
memset(&val, 0, sizeof(pv_value_t));
if(pv_printf_s(msg, model, &val.rs)!=0)
{
LM_ERR("cannot eval second parameter\n");
goto error;
}
val.flags = PV_VAL_STR;
if(pv_set_value(msg, spec, EQ_T, &val)<0)
{
LM_ERR("setting PV failed\n");
goto error;
}
ret = 1;
break;
default:
LM_ALERT("BUG - unknown type %d\n", a->type);
goto error;
}
if((unsigned char)a->type!=IF_T && (unsigned char)a->type!=ROUTE_T)
return_code = ret;
/*skip:*/
return ret;
error:
LM_ERR("error at line: %d\n", a->line);
return ret;
error_uri:
LM_ERR("set*: uri too long\n");
if (new_uri) pkg_free(new_uri);
return E_UNSPEC;
error_fwd_uri:
return ret;
}
bool_t giga_rpc_mkdir_1_svc(giga_dir_id dir_id, giga_pathname path, mode_t mode,
giga_result_t *rpc_reply,
struct svc_req *rqstp)
{
(void)rqstp;
assert(rpc_reply);
assert(path);
logMessage(LOG_TRACE, __func__,
"==> RPC_mkdir_recv(path=%s,mode=0%3o)", path, mode);
bzero(rpc_reply, sizeof(giga_result_t));
struct giga_directory *dir = cache_fetch(&dir_id);
if (dir == NULL) {
rpc_reply->errnum = -EIO;
logMessage(LOG_DEBUG, __func__, "Dir (id=%d) not in cache!", dir_id);
return true;
}
// (1): get the giga index/partition for operation
int index = giga_get_index_for_file(&dir->mapping, (const char*)path);
int server = giga_get_server_for_index(&dir->mapping, index);
// (2): is this the correct server? NO --> (errnum=-EAGAIN) and return
if (server != giga_options_t.serverID) {
rpc_reply->errnum = -EAGAIN;
memcpy(&(rpc_reply->giga_result_t_u.bitmap),
&dir->mapping, sizeof(dir->mapping));
logMessage(LOG_TRACE, __func__, "req for server-%d reached server-%d.",
server, giga_options_t.serverID);
return true;
}
char path_name[MAX_LEN];
switch (giga_options_t.backend_type) {
case BACKEND_RPC_LOCALFS:
snprintf(path_name, sizeof(path_name),
"%s/%s", giga_options_t.mountpoint, path);
rpc_reply->errnum = local_mkdir(path_name, mode);
break;
case BACKEND_RPC_LEVELDB:
// create object in the underlying file system
snprintf(path_name, sizeof(path_name),
"%s/%s", giga_options_t.mountpoint, path);
rpc_reply->errnum = local_mkdir(path_name, mode);
// create object entry (metadata) in levelDB
object_id += 1;
rpc_reply->errnum = leveldb_create(ldb_mds, dir_id, index,
OBJ_DIR,
object_id, path, path_name);
break;
default:
break;
}
logMessage(LOG_TRACE, __func__,
"RPC_mkdir_reply(status=%d)", rpc_reply->errnum);
return true;
}
static struct mi_root *mi_cachefetch(struct mi_root *cmd, void *param)
{
str mc_system;
str attr;
str value;
struct mi_node* node= NULL;
struct mi_root *rpl_tree= NULL;
int ret;
if(cmd == NULL)
{
LM_ERR("NULL command\n");
return init_mi_tree(404, "NULL command", 12);
}
node = cmd->node.kids;
if(node == NULL)
return init_mi_tree(404, "Too few arguments", 17);
mc_system = node->value;
if(mc_system.s == NULL || mc_system.len== 0)
{
LM_ERR( "empty memory cache system parameter\n");
return init_mi_tree(404, "Empty memory cache id", 21);
}
node = node->next;
if(node == NULL)
return init_mi_tree(404, "Too few arguments", 17);
attr = node->value;
if(attr.s == NULL || attr.len== 0)
{
LM_ERR( "empty attribute name parameter\n");
return init_mi_tree(404, "Empty attribute name", 20);
}
node = node->next;
if(node != NULL)
return init_mi_tree(404, "Too many arguments", 18);
ret = cache_fetch(&mc_system, &attr, &value);
if(ret== -1)
{
LM_ERR("cache_fetch command failed\n");
return init_mi_tree(500, "Cache fetch command failed", 26);
}
rpl_tree = init_mi_tree( 200, MI_OK_S, MI_OK_LEN);
if (rpl_tree==0)
{
if(value.s)
pkg_free(value.s);
return 0;
}
if(ret == -2 || value.s == 0 || value.len == 0)
{
addf_mi_node_child( &rpl_tree->node, 0, 0, 0, "Value not found");
goto done;
}
addf_mi_node_child( &rpl_tree->node, 0, 0, 0, "%.*s = [%.*s]", attr.len,
attr.s, value.len, value.s);
pkg_free(value.s);
done:
return rpl_tree;
}
ide_prepare(ptr->sector);
do_write(&ptr->content);
}
/* issue a read command */
ide_prepare(sector);
issue_read();
do_read(&ptr->content);
ptr->used = TRUE;
ptr->sector = sector;
ptr->dirty = FALSE;
}
return ptr;
}
static uint_8
read_byte(uint_32 offset) {
uint_32 sector = offset >> 9;
//printk("help\n");
struct SectorCache *ptr = cache_fetch(sector);
//printk("help again\n");
return ptr->content[offset & 511];
}
static void
write_byte(uint_32 offset, uint_8 data) {
uint_32 sector = offset >> 9;
struct SectorCache *ptr = cache_fetch(sector);
ptr->content[offset & 511] = data;
ptr->dirty = TRUE;
}
void cache_recvmsg()
{
unsigned int recv_ip;
unsigned short recv_port;
unsigned char buf[1024];
struct sockaddr_in si_other;
socklen_t slen=sizeof(si_other);
uint ticks = GetTickCount();
struct cs_cachepeer_data *peer;
int received = recvfrom( cfg.cachesock, buf, sizeof(buf), 0, (struct sockaddr*)&si_other, &slen);
memcpy( &recv_ip, &si_other.sin_addr, 4);
recv_port = ntohs(si_other.sin_port);
if (received>0) {
if (flag_debugnet) {
debugf(" cache: recv data (%d) from address (%s:%d)\n", received, ip2string(recv_ip), recv_port );
debughex(buf,received);
}
// Store Data
struct cache_data req;
switch(buf[0]) {
case TYPE_REQUEST:
// Check Peer
peer = getpeerbyaddr(recv_ip,recv_port);
if (!peer) {
peer = getpeerbyip(recv_ip);
if (!peer) break;
}
peer->lastactivity = ticks;
//peer->totreq++;
// Check Multics diferent version
if ( !strcmp("MultiCS",peer->program) && (!strcmp("r63",peer->version)||!strcmp("r64",peer->version)||!strcmp("r65",peer->version)||!strcmp("r66",peer->version)||!strcmp("r67",peer->version)||!strcmp("r68",peer->version)||!strcmp("r69",peer->version)||!strcmp("r70",peer->version)||!strcmp("r71",peer->version)||!strcmp("r72",peer->version)||!strcmp("r73",peer->version)||!strcmp("r74",peer->version)||!strcmp("r75",peer->version)||!strcmp("r76",peer->version)||!strcmp("r77",peer->version)||!strcmp("r78",peer->version)||!strcmp("r79",peer->version)||!strcmp("r80",peer->version)||!strcmp("r81",peer->version)||!strcmp("r82",peer->version)||!strcmp("r83",peer->version)||!strcmp("r84",peer->version)||!strcmp("r85",peer->version)) ) break;
// Check CSP
if (received==20) { // arbiter number
strcpy(peer->program,"CSP");
break;
}
// Check Status
if (peer->disabled) break;
// Get DATA
req.tag = buf[1];
req.sid = (buf[2]<<8) | buf[3];
req.onid = (buf[4]<<8) | buf[5];
req.caid = (buf[6]<<8) | buf[7];
req.hash = (buf[8]<<24) | (buf[9]<<16) | (buf[10]<<8) |buf[11];
// Check Cache Request
if (!cache_check(&req)) break;
//
peer->reqnb++;
// ADD CACHE
struct cache_data *pcache = cache_fetch( &req );
if (pcache==NULL) {
//*debugf(" [CACHE] << Cache Request from %s %04x:%04x:%08x\n", peer->host->name, req.caid, req.sid, req.hash);
pcache = cache_new( &req );
if (cfg.cache.trackermode) {
// Send REQUEST to all Peers
struct cs_cachepeer_data *p = cfg.cachepeer;
while (p) {
if (!p->disabled)
if (p->host->ip && p->port)
if ( (p->lastactivity+75000)>ticks )
if ( !p->fblock0onid || pcache->onid )
cache_send_request(pcache,p);
p = p->next;
}
pcache->sendcache = 1;
cfg.cachereq++;
}
}
else if (!cfg.cache.trackermode) {
if ( (pcache->status==CACHE_STAT_DCW)&&(pcache->sendcache!=2) ) {
//debugf(" [CACHE] << Request Reply >> to peer %s %04x:%04x:%08x\n", peer->host->name, req.caid, req.sid, req.hash);
peer->ihitfwd++;
peer->hitfwd++;
cache_send_reply(pcache,peer);
}
}
break;
case TYPE_REPLY:
// Check Peer
peer = getpeerbyaddr(recv_ip,recv_port);
if (!peer) {
peer = getpeerbyip(recv_ip);
if (!peer) break;
}
peer->lastactivity = ticks;
//peer->totrep++;
// Check Multics diferent version
if ( !strcmp("MultiCS",peer->program) && (!strcmp("r63",peer->version)||!strcmp("r64",peer->version)||!strcmp("r65",peer->version)||!strcmp("r66",peer->version)||!strcmp("r67",peer->version)||!strcmp("r68",peer->version)||!strcmp("r69",peer->version)||!strcmp("r70",peer->version)||!strcmp("r71",peer->version)||!strcmp("r72",peer->version)||!strcmp("r73",peer->version)||!strcmp("r74",peer->version)||!strcmp("r75",peer->version)||!strcmp("r76",peer->version)||!strcmp("r77",peer->version)||!strcmp("r78",peer->version)||!strcmp("r79",peer->version)||!strcmp("r80",peer->version)||!strcmp("r81",peer->version)||!strcmp("r82",peer->version)||!strcmp("r83",peer->version)||!strcmp("r84",peer->version)||!strcmp("r85",peer->version)) ) break;
// Check Status
if (peer->disabled) break;
// 02 80 00CD 0001 0500 8D1DB359 80 // failed
// 02 80 00CD 0001 0500 8D1DB359 80 00CD 0000 0500 63339F359A663232B73158405A255DDC // OLD
// 02 80 001F 0001 0100 9A3BA1C1 80 BC02DB99DE3D526D5702D42D4C249505 0005 6361726431 // NEW
if (buf[12]!=buf[1]) {
//peer->rep_badheader++;
break;
}
req.tag = buf[1];
req.sid = (buf[2]<<8) | buf[3];
req.onid = (buf[4]<<8) | buf[5];
req.caid = (buf[6]<<8) | buf[7];
req.hash = (buf[8]<<24) | (buf[9]<<16) | (buf[10]<<8) |buf[11];
// Check Cache Request
if (!cache_check(&req)) {
//peer->rep_badfields++;
break;
}
//
if (received==13) { // FAILED
//peer->rep_failed++;
//*debugf(" [CACHE] <| Failed Cache Reply from %s (CAID:%04x SID:%04x ONID:%04x)\n", peer->host->name, req.caid, req.sid, req.onid);
// NOTHING TO DO
break;
}
else if (received>=29) {
// 02 80 001F 0001 0100 9A3BA1C1 80 BC02DB99DE3D526D5702D42D4C249505 0005 6361726431 // NEW
if ( !acceptDCW(buf+13) ) {
//peer->rep_baddcw++;
break;
}
//*debugf(" [CACHE] << Good Cache Reply from %s %04x:%04x:%08x (ONID:%04x)\n", peer->host->name, req.caid, req.sid, req.hash, req.onid);
peer->repok++; // Request+Reply
// Search for Cache data
struct cache_data *pcache = cache_fetch( &req );
if (pcache==NULL) pcache = cache_new( &req );
if (pcache->status!=CACHE_STAT_DCW) {
//*debugf(" [CACHE] Update Cache DCW %04x:%04x:%08x\n", pcache->caid, pcache->sid, pcache->hash);
pcache->peerid = peer->id;
memcpy(pcache->cw, buf+13, 16);
pcache->status = CACHE_STAT_DCW;
if (pcache->sendpipe) {
uchar buf[128]; // 32 por defecto
buf[0] = PIPE_CACHE_FIND_SUCCESS;
buf[1] = 11+2+16; // Data length
buf[2] = pcache->tag;
buf[3] = pcache->sid>>8; buf[4] = pcache->sid&0xff;
buf[5] = pcache->onid>>8; buf[6] = pcache->onid&0xff;
buf[7] = pcache->caid>>8; buf[8] = pcache->caid&0xff;
buf[9] = pcache->hash>>24; buf[10] = pcache->hash>>16; buf[11] = pcache->hash>>8; buf[12] = pcache->hash & 0xff;
buf[13] = peer->id>>8; buf[14] = peer->id&0xff;
memcpy( buf+15, pcache->cw, 16);
//*debugf(" pipe Cache->Ecm: PIPE_CACHE_FIND_SUCCESS %04x:%04x:%08x\n",pcache->caid, pcache->sid, pcache->hash); // debughex(buf, 13+16);
pipe_send( srvsocks[1], buf, 13+2+16);
//pcache->sendpipe = 0;
}
if (cfg.cache.trackermode) {
// Send REQUEST to all Peers
struct cs_cachepeer_data *p = cfg.cachepeer;
while (p) {
if (!p->disabled)
if (p->host->ip && p->port)
if ( (p->lastactivity+75000)>ticks )
if ( !p->fblock0onid || pcache->onid )
cache_send_reply(pcache,p);
p = p->next;
}
pcache->sendcache = 2;
cfg.cacherep++;
}
}
else if ( pcache->sendpipe && memcmp(pcache->cw, buf+13, 16) ) {
// resend to server
pcache->peerid = peer->id;
memcpy(pcache->cw, buf+13, 16);
pcache->status = CACHE_STAT_DCW;
uchar buf[128]; // 32 por defecto
buf[0] = PIPE_CACHE_FIND_SUCCESS;
buf[1] = 11+2+16; // Data length
buf[2] = pcache->tag;
buf[3] = pcache->sid>>8; buf[4] = pcache->sid&0xff;
buf[5] = pcache->onid>>8; buf[6] = pcache->onid&0xff;
buf[7] = pcache->caid>>8; buf[8] = pcache->caid&0xff;
buf[9] = pcache->hash>>24; buf[10] = pcache->hash>>16; buf[11] = pcache->hash>>8; buf[12] = pcache->hash & 0xff;
buf[13] = peer->id>>8; buf[14] = peer->id&0xff;
memcpy( buf+15, pcache->cw, 16);
pipe_send( srvsocks[1], buf, 13+2+16);
}
