pdt.c

性能优秀的SIP Proxy

					}
					break;
				case PDT_DELETE:
					if(itree==NULL)
					{
						LOG(L_ERR,
							"PDT:pdt_sync_cache: Error to remove from tree, tree does not exist\n");
						goto error;
					}
					if(pdt_remove_prefix_from_tree(itree, &it->sdomain, &ito->cell->prefix)!=0)
					{
						LOG(L_ERR,
							"PDT:pdt_sync_cache: Error to remove from tree\n");
						goto error;
					}
					break;
				default:
					LOG(L_ERR, "PDT:pdt_sync_cache: unknown operation\n");
			}
			ito->count++;
			ito = ito->n;
		}
		if(it->diff!=NULL)
			itree->idsync = it->diff->id;
		it = it->next;
	}


	lock_release(&_dhash->hl_lock);
	return 0;
error:
	lock_release(&_dhash->hl_lock);
	return -1;
}

void pdt_clean_cache(unsigned int ticks, void *param)
{
	pd_op_t *ito, *tmp;
	hash_t *it;

	/* DBG("PDT:pdt_clean_cache: ...\n"); */
	
	if(_dhash==NULL)
	{
		LOG(L_ERR, "PDT:pdt_clean_cache: strange situation\n");
		return;
	}
	
	lock_get(&_dhash->hl_lock);

	it = _dhash->hash;
	while(it!=NULL)
	{
		ito = it->diff;
		while(ito!=NULL)
		{
			if(ito->count >= _dhash->workers)
			{
				DBG("PDT:pdt_clean_cache: cleaning sdomain<%.*s> op[%d]=%d...\n",
					it->sdomain.len, it->sdomain.s, ito->id, ito->op);
				free_cell(ito->cell);
				if(ito->p!=NULL)
					(ito->p)->n = ito->n;
				else
					it->diff = ito->n;
				if(ito->n!=NULL)
					(ito->n)->p = ito->p;
				tmp = ito;
				ito = ito->n;
				shm_free(tmp);
			} 
			else
				ito = ito->n;
		}
		it = it->next;	
	}
	lock_release(&_dhash->hl_lock);
	return;
}

/**
 *	Fifo command example:
 * 
 *	---
 *	 :pdt_add:[response_file]\n
 *	 sdomain\n
 *	 prefix\n
 *	 domain\n
 *	 \n
 * 	--
 */
int pdt_fifo_add(FILE *stream, char *response_file)
{
	db_key_t db_keys[NR_KEYS] = {sdomain_column, prefix_column, domain_column};
	db_val_t db_vals[NR_KEYS];
	db_op_t  db_ops[NR_KEYS] = {OP_EQ, OP_EQ};

	char dbuf[256], sdbuf[256], pbuf[256];
	str sd, sp, sdomain;

	if(_dhash==NULL)
	{
		LOG(L_ERR, "PDT:pdt_fifo_add: strange situation\n");
		fifo_reply(response_file, "500 pdt_fifo_add - server error\n");
		return -1;
	}

	/* read sdomain */
	sdomain.s = sdbuf;
	if(!read_line(sdomain.s, 255, stream, &sdomain.len) || sdomain.len==0)	
	{
		LOG(L_ERR, "PDT:pdt_fifo_add: could not read domain\n");
		fifo_reply(response_file, "400 pdt_fifo_add - domain not found\n");
		return 1;
	}
	sdbuf[sdomain.len] = '\0';
	if(*sdomain.s=='\0' || *sdomain.s=='.')
	{
		LOG(L_INFO, "PDT:pdt_fifo_add: empty sdomain\n");
		fifo_reply(response_file, "400 pdt_fifo_add - empty param\n");
		return 1;
	}
	
	/* read prefix */
	sp.s = pbuf;
	if(!read_line(sp.s, 255, stream, &sp.len) || sp.len==0)	
	{
		LOG(L_ERR, "PDT:pdt_fifo_add: could not read prefix\n");
		fifo_reply(response_file, "400 pdt_fifo_add - prefix not found\n");
		return 1;
	}
	pbuf[sp.len] = '\0';
	if(*sp.s=='\0' || *sp.s=='.')
	{
		LOG(L_INFO, "PDT:pdt_fifo_add: empty prefix\n");
		fifo_reply(response_file, "400 pdt_fifo_add - empty param\n");
		return 1;
	}

	while(sp.s!=NULL && *sp.s!='\0')
	{
		if(*sp.s < '0' || *sp.s > '9')
		{
			LOG(L_ERR, "PDT:pdt_fifo_add: bad prefix [%s]\n", pbuf);
			fifo_reply(response_file, "400 pdt_fifo_add - bad prefix\n");
			return 1;
		}
		sp.s++;
	}
	sp.s = pbuf;

	/* read domain */
	sd.s = dbuf;
	if(!read_line(sd.s, 255, stream, &sd.len) || sd.len==0)	
	{
		LOG(L_ERR, "PDT:pdt_fifo_add: could not read domain\n");
		fifo_reply(response_file, "400 pdt_fifo_add - domain not found\n");
		return 1;
	}
	dbuf[sd.len] = '\0';
	if(*sd.s=='\0' || *sd.s=='.')
	{
		LOG(L_INFO, "PDT:pdt_fifo_add: empty domain\n");
		fifo_reply(response_file, "400 pdt_fifo_add - empty param\n");
		return 1;
	}

	if(pdt_check_pd(_dhash, &sdomain, &sp, &sd)==1)
	{
		LOG(L_ERR, "PDT:pdt_fifo_add: (sdomain,prefix,domain) exists\n");
		fifo_reply(response_file,
			"400 pdt_fifo_add - (sdomain,prefix,domain) exists already\n");
		return 1;
	}
	db_vals[0].type = DB_STR;
	db_vals[0].nul = 0;
	db_vals[0].val.str_val.s = sdomain.s;
	db_vals[0].val.str_val.len = sdomain.len;

	db_vals[1].type = DB_STR;
	db_vals[1].nul = 0;
	db_vals[1].val.str_val.s = sp.s;
	db_vals[1].val.str_val.len = sp.len;

	db_vals[2].type = DB_STR;
	db_vals[2].nul = 0;
	db_vals[2].val.str_val.s = sd.s;
	db_vals[2].val.str_val.len = sd.len;
	
	/* insert a new domain into database */
	if(pdt_dbf.insert(db_con, db_keys, db_vals, NR_KEYS)<0)
	{
		LOG(L_ERR, "PDT:pdt_fifo_add: error storing new prefix/domain\n");
		fifo_reply(response_file, "430 Cannot store prefix/domain\n");
		return -1;
	}
	
	if(pdt_add_to_hash(_dhash, &sdomain, &sp, &sd)!=0)
	{
		LOG(L_ERR, "PDT:pdt_fifo_add: could not add to cache\n");
		fifo_reply(response_file, "431 could not add to cache\n");
		goto error;
	}

	fifo_reply(response_file, "230 Added <%.*s> [%.*s] <%.*s>\n",
		sdomain.len, sdomain.s, sp.len, sp.s, sd.len, sd.s);

	return 0;
	
error:
	if(pdt_dbf.delete(db_con, db_keys, db_ops, db_vals, NR_KEYS)<0)
		LOG(L_ERR,"PDT:pdt_fifo_add: database/cache are inconsistent\n");
	
	return -1;
}

/**
 *	Fifo command example:
 * 
 *	---
 *	 :pdt_delete:[response_file]\n
 *	 sdomain
 *	 domain\n
 *	 \n
 * 	--
 */
static int pdt_fifo_delete(FILE *stream, char *response_file)
{
	char sdbuf[256], sdomainbuf[256];
	str sd, sdomain;
	int ret;
	
	db_key_t db_keys[2] = {sdomain_column, domain_column};
	db_val_t db_vals[2];
	db_op_t  db_ops[2] = {OP_EQ, OP_EQ};

	if(_dhash==NULL)
	{
		LOG(L_ERR, "PDT:pdt_fifo_delete: strange situation\n");
		fifo_reply(response_file, "500 pdt_fifo_delete - server error\n");
		return -1;
	}

	/* read sdomain */
	sdomain.s = sdomainbuf;
	if(!read_line(sdomain.s, 255, stream, &sdomain.len) || sdomain.len==0)	
	{
		LOG(L_ERR, "PDT:pdt_fifo_delete: could not read sdomain\n");
		fifo_reply(response_file, "400 pdt_fifo_delete - sdomain not found\n");
		return 1;
	}
	sdomainbuf[sdomain.len] = '\0';
	if(*sdomain.s=='\0' || *sdomain.s=='.')
	{
		LOG(L_INFO, "PDT:pdt_fifo_delete: empty sdomain\n");
		fifo_reply(response_file, "400 pdt_fifo_delete - empty param\n");
		return 1;
	}
	
	/* read domain */
	sd.s = sdbuf;
	if(!read_line(sd.s, 255, stream, &sd.len) || sd.len==0)	
	{
		LOG(L_ERR, "PDT:pdt_fifo_delete: could not read domain\n");
		fifo_reply(response_file, "400 pdt_fifo_delete - domain not found\n");
		return 1;
	}
	sdbuf[sd.len] = '\0';
	if(*sd.s=='\0' || *sd.s=='.')
	{
		LOG(L_INFO, "PDT:pdt_fifo_delete: empty domain\n");
		fifo_reply(response_file, "400 pdt_fifo_delete - empty param\n");
		return 1;
	}

	if((ret = pdt_remove_from_hash_list(_dhash, &sdomain, &sd))<0)
	{
		DBG("PDT:pdt_fifo_delete: error encountered when deleting domain\n");
		fifo_reply(response_file, "error encountered when deleting domain!\n");
		return -1;
	}
	
	if(ret==1)
	{
		DBG("PDT:pdt_fifo_delete: prefix for sdomain [%.*s]domain [%.*s] not found\n",
				sdomain.len, sdomain.s, sd.len, sd.s);
		fifo_reply(response_file, "404 domain not found!\n");
		return 0;
	}
	
//	pdt_print_hash_list(_dhash);

	/* ret=0 means domain was deleted from cache, so it must be deleted from db */
	db_vals[0].type = DB_STR;
	db_vals[0].nul = 0;
	db_vals[0].val.str_val.s = sdomain.s;
	db_vals[0].val.str_val.len = sdomain.len;
	
	db_vals[1].type = DB_STR;
	db_vals[1].nul = 0;
	db_vals[1].val.str_val.s = sd.s;
	db_vals[1].val.str_val.len = sd.len;

	if(pdt_dbf.delete(db_con, db_keys, db_ops, db_vals, 2)<0)
	{
		LOG(L_ERR,"PDT:pdt_fifo_delete: database/cache are inconsistent\n");
		fifo_reply(response_file, "602 database/cache are inconsistent!\n");
	} 
	else 
		fifo_reply(response_file, "200 domain removed!\n");
		
	return 0;
}

/**
 *	Fifo command example:
 * 
 *	---
 *	 :pdt_list:[response_file]\n
 *	 sdomain\n
 *	 prefix\n
 *	 domain\n
 *	 \n
 * 	--
 *
 * 	- '.' (dot) means NULL value 
 * 	- the comparison operation is 'START WITH' -- if domain is 'a' then
 * 	  all domains starting with 'a' are listed
 */

static int pdt_fifo_list(FILE *stream, char *response_file)
{
	char sdbuf[256], pbuf[256], sdomainbuf[256];
	str sd, sp, sdomain;
	pd_t *it;
	int i;
	FILE *freply=NULL;
	hash_t *h;

	if(_dhash==NULL)
	{
		LOG(L_ERR, "PDT:pdt_fifo_list: strange situation\n");
		fifo_reply(response_file, "500 pdt_fifo_list - server error\n");
		return -1;
	}

	sdomain.s = sdomainbuf;
	if(!read_line(sdomain.s, 255, stream, &sdomain.len) || sdomain.len==0)	
	{
		LOG(L_ERR, "PDT:pdt_fifo_list: could not read domain\n");
		fifo_reply(response_file, "400 pdt_fifo_list - domain not found\n");
		return 1;
	}
	sdomainbuf[sdomain.len] = '\0';
	if(*sdomain.s=='\0' || *sdomain.s=='.')
	{
		sdomain.s   = NULL;
		sdomain.len = 0;
	}
	
	sp.s = pbuf;
	if(!read_line(sp.s, 255, stream, &sp.len) || sp.len==0)	
	{
		LOG(L_ERR, "PDT:pdt_fifo_list: could not read prefix\n");
		fifo_reply(response_file, "400 pdt_fifo_list - prefix not found\n");
		return 1;
	}
	pbuf[sp.len] = '\0';

	if(*sp.s!='\0' && *sp.s!='.')
	{
		while(sp.s!=NULL && *sp.s!='\0')
		{
			if(*sp.s < '0' || *sp.s > '9')
			{
				LOG(L_ERR, "PDT:pdt_fifo_list: bad prefix [%s]\n", pbuf);
				fifo_reply(response_file, "400 pdt_fifo_list - bad prefix\n");
				return 1;
			}
			sp.s++;
		}
		sp.s = pbuf;
	} else {
		sp.s   = NULL;
		sp.len = 0;
	}

	sd.s = sdbuf;
	if(!read_line(sd.s, 255, stream, &sd.len) || sd.len==0)	
	{
		LOG(L_ERR, "PDT:pdt_fifo_list: could not read domain\n");
		fifo_reply(response_file, "400 pdt_fifo_list - domain not found\n");
		return 1;
	}
	sdbuf[sd.len] = '\0';
	if(*sd.s=='\0' || *sd.s=='.')
	{
		sd.s   = NULL;
		sd.len = 0;
	}

	freply = open_reply_pipe(response_file);
	if(freply==NULL)
	{
		LOG(L_ERR, "PDT:pdt_fifo_list: can't open reply fifo '%s'\n",
				response_file);
		return -1;
	}
	
	lock_get(&_dhash->hl_lock);

	h = _dhash->hash;
	while(h!=NULL)
	{
		if(sdomain.s==NULL || 
			(sdomain.s!=NULL && h->sdomain.len>=sdomain.len && 
			 strncmp(h->sdomain.s, sdomain.s, sdomain.len)==0))
		{
			for(i=0; i<h->hash_size; i++)
			{
				it = h->dhash[i];
				while(it!=NULL)
				{
					if((sp.s==NULL && sd.s==NULL)
						|| (sp.s!=NULL && it->prefix.len>=sp.len &&
							strncmp(it->prefix.s, sp.s, sp.len)==0)
						|| (sd.s!=NULL && it->domain.len>=sd.len &&
							strncasecmp(it->domain.s, sd.s, sd.len)==0))
					fprintf(freply, "%.*s %.*s %.*s\n",
						h->sdomain.len, h->sdomain.s,
						it->prefix.len, it->prefix.s,
						it->domain.len, it->domain.s);
					it = it->n;
				}
			}
		}
			h = h->next;
	}

	lock_release(&_dhash->hl_lock);
	
	fprintf(freply, "\n*200 OK\n");
	if(freply!=NULL)
		fclose(freply);

	return 0;
}

static int get_domainprefix_unixsock(str* msg)
{
	return 0;
#if 0
	db_key_t db_keys[NR_KEYS];
	db_val_t db_vals[NR_KEYS];
	db_op_t  db_ops[NR_KEYS] = {OP_EQ, OP_EQ};
	code_t code;
	dc_t* cell; 
	str sdomain, sauth;
	int authorized=0;
		
	/* read a line -the domain name parameter- from the fifo */
	if(unixsock_read_line(&sdomain, msg) != 0)	
	{
		unixsock_reply_asciiz("400 Domain expected\n");
		goto send_err;
	}

	/* read a line -the authorization to register new domains- from the fifo */
	if(unixsock_read_line(&sauth, msg) != 0)
	{	
		unixsock_reply_asciiz("400 Authorization expected\n");
		goto send_err;
	}

	sdomain.s[sdomain.len] = '\0';

	/* see what kind of user we have */
	authorized = sauth.s[0]-'0';

	lock_get(&l);

	/* search the domain in the hashtable */
	cell = get_code_from_hash(hash->dhash, hash->hash_size, sdomain.s);
	
	/* the domain is registered */
	if(cell)
	{

		lock_release(&l);
			
		/* domain already in the database */
		unixsock_reply_printf("201 Domain name=%.*s Domain code=%d%d\n",
				      sdomain.len, ZSW(sdomain.s), cell->code, code_terminator);
		unixsock_reply_send();
		return 0;
		
	}
	
	/* domain not registered yet */
	/* user not authorized to register new domains */	
	if(!authorized)
	{
		lock_release(&l);
		unixsock_reply_asciiz("203 Domain name not registered yet\n");
		unixsock_reply_send();
		return 0;
	}

	code = *next_code;
	*next_code = apply_correction(code+1);
		

	/* prepare for insertion into database */
	db_keys[0] = DB_KEY_CODE;
	db_keys[1] = DB_KEY_NAME;

	db_vals[0].type = DB_INT;
	db_vals[0].nul = 0;
	db_vals[0].val.int_val = code;

	db_vals[1].type = DB_STR;
	db_vals[1].nul = 0;
	db_vals[1].val.str_val.s = sdomain.s;
	db_vals[1].val.str_val.len = sdomain.len;
	DBG("%d %.*s\n", code, sdomain.len, sdomain.s);
			
	/* insert a new domain into database */
	if(pdt_dbf.insert(db_con, db_keys, db_vals, NR_KEYS)<0)
	{
		/* next available code is still code */
		*next_code = code;
		lock_release(&l);
		LOG(L_ERR, "PDT: get_domaincode: error storing a"
				" new domain\n");
		unixsock_reply_asciiz("204 Cannot register the new domain in a consistent way\n");
		unixsock_reply_send();
		return -1;
	}
	
	/* insert the new domain into hashtables, too */
	cell = new_cell(sdomain.s, code);
	if(add_to_double_hash(hash, cell)<0)
		goto error;		

	lock_release(&l);

	/* user authorized to register new domains */
	unixsock_reply_printf("202 Domain name=%.*s New domain code=%d%d\n",
			      sdomain.len, ZSW(sdomain.s), code, code_terminator);

	unixsock_reply_send();
	return 0;

 error:
	/* next available code is still code */
	*next_code = code;
	/* delete from database */
	if(pdt_dbf.delete(db_con, db_keys, db_ops, db_vals, NR_KEYS)<0)
		LOG(L_ERR,"PDT: get_domaincode: database/share-memory are inconsistent\n");
	lock_release(&l);
	unixsock_reply_asciiz("500 Database/shared-memory are inconsistent\n");
send_err:
	unixsock_reply_send();
	return -1;
#endif
}