int main (int argc, char ** argv )
{
setvbuf(stdin, buff_stdin, _IOFBF, 0x1000);
setvbuf(stdout, buff_stdout, _IOFBF, 0x1000);
char *real_obj_name = NULL;
Input_Obj_Type tMode;
tMode = get_work_mode (argc, argv);
if ( save_settings_to_fs () < 0 )
return -1;
if ( ( real_obj_name = prepare_object (tMode)) == NULL )
{
return -1;
}
docs_to_xml( TEMP_DIR, tMode );
do_index_xml ();
save_index ();
//mylistdir( "/" );
return 0;
}
int main (int argc, char ** argv )
{
// setvbuf(stdin, buff_stdin, _IOFBF, 0x1000);
// setvbuf(stdout, buff_stdout, _IOFBF, 0x1000);
char *real_obj_name = NULL;
int mode = 0;
mode = get_work_mode (argc, argv);
if ( save_settings_to_fs () < 0 )
return -1;
if ( ( real_obj_name = prepare_object (mode)) == NULL )
{
return -1;
}
test_read_dir( "/docs/list.txt" );
docs_to_xml( TEMP_DIR, mode );
do_index_xml ();
save_index ();
mylistdir( "/" );
return 0;
}
int main(int argc, char *argv[]) {
char *infile, *outfile;
uchar *text;
char *params = NULL;
ulong text_len;
void *index;
int error, i;
double start, end;
if (argc < 3) print_usage(argv[0]);
if (argc > 3) {
int nchars, len;
nchars = argc-3;
for(i=2;i<argc;i++)
nchars += strlen(argv[i]);
params = (char *) malloc((nchars+1)*sizeof(char));
params[nchars] = '\0';
nchars = 0;
for(i=3;i<argc;i++) {
len = strlen(argv[i]);
strncpy(params+nchars,argv[i],len);
params[nchars+len] = ' ';
nchars += len+1;
}
params[nchars-1] = '\0';
}
infile = argv[1];
outfile = argv[2];
start = getTime();
error = read_file(infile, &text, &text_len);
IFERROR(error);
error = build_index(text, text_len, params, &index);
IFERROR(error);
error = save_index(index, outfile);
IFERROR(error);
end = getTime();
fprintf(stderr, "Building time: %.3f secs\n", end-start );
ulong index_len;
index_size(index, &index_len);
fprintf(stdout,"Input: %lu bytes --> Output %lu bytes.\n", text_len, index_len);
fprintf(stdout,"Overall compression --> %.2f%% (%.2f bits per char).\n\n",
(100.0*index_len)/text_len, (index_len*8.0)/text_len);
error = free_index(index);
IFERROR(error);
exit(0);
}
/**
* WARNING: This function actually deletes a mobile from the world.
*
* @param char_data *ch The person doing the deleting.
* @param mob_vnum vnum The vnum to delete.
*/
void olc_delete_mobile(char_data *ch, mob_vnum vnum) {
void extract_pending_chars();
void remove_mobile_from_table(char_data *mob);
char_data *proto, *mob_iter, *next_mob;
descriptor_data *desc;
struct global_data *glb, *next_glb;
room_template *rmt, *next_rmt;
sector_data *sect, *next_sect;
crop_data *crop, *next_crop;
bld_data *bld, *next_bld;
bool found;
if (!(proto = mob_proto(vnum))) {
msg_to_char(ch, "There is no such mobile %d.\r\n", vnum);
return;
}
if (HASH_COUNT(mobile_table) <= 1) {
msg_to_char(ch, "You can't delete the last mob.\r\n");
return;
}
// remove mobs from the list: DO THIS FIRST
for (mob_iter = character_list; mob_iter; mob_iter = next_mob) {
next_mob = mob_iter->next;
if (IS_NPC(mob_iter)) {
if (GET_MOB_VNUM(mob_iter) == vnum) {
// this is the removed mob
act("$n has been deleted.", FALSE, mob_iter, NULL, NULL, TO_ROOM);
extract_char(mob_iter);
}
}
}
// their data will already be free, so we need to clear them out now
extract_pending_chars();
// pull from hash ONLY after removing from the world
remove_mobile_from_table(proto);
// save mob index and mob file now so there's no trouble later
save_index(DB_BOOT_MOB);
save_library_file_for_vnum(DB_BOOT_MOB, vnum);
// update buildings
HASH_ITER(hh, building_table, bld, next_bld) {
found = delete_mob_from_spawn_list(&GET_BLD_SPAWNS(bld), vnum);
found |= delete_from_interaction_list(&GET_BLD_INTERACTIONS(bld), TYPE_MOB, vnum);
if (found) {
save_library_file_for_vnum(DB_BOOT_BLD, GET_BLD_VNUM(bld));
}
}
/**
* WARNING: This function actually deletes a crop.
*
* @param char_data *ch The person doing the deleting.
* @param crop_vnum vnum The vnum to delete.
*/
void olc_delete_crop(char_data *ch, crop_vnum vnum) {
void remove_crop_from_table(crop_data *crop);
extern const sector_vnum climate_default_sector[NUM_CLIMATES];
obj_data *obj, *next_obj;
descriptor_data *desc;
struct map_data *map;
room_data *room;
crop_data *crop;
sector_data *base = NULL;
int count;
if (!(crop = crop_proto(vnum))) {
msg_to_char(ch, "There is no such crop %d.\r\n", vnum);
return;
}
if (HASH_COUNT(crop_table) <= 1) {
msg_to_char(ch, "You can't delete the last crop.\r\n");
return;
}
// remove it from the hash table first
remove_crop_from_table(crop);
// save base sect for later
base = sector_proto(climate_default_sector[GET_CROP_CLIMATE(crop)]);
// save index and crop file now
save_index(DB_BOOT_CROP);
save_library_file_for_vnum(DB_BOOT_CROP, vnum);
// update world
count = 0;
LL_FOREACH(land_map, map) {
room = real_real_room(map->vnum);
if (map->crop_type == crop || (room && ROOM_CROP(room) == crop)) {
if (!room) {
room = real_room(map->vnum);
}
set_crop_type(room, NULL); // remove it explicitly
change_terrain(room, GET_SECT_VNUM(base));
++count;
}
}
/**
* Creates a new crop entry.
*
* @param crop_vnum vnum The number to create.
* @return crop_data* The new crop's prototype.
*/
crop_data* create_crop_table_entry(crop_vnum vnum) {
void add_crop_to_table(crop_data *crop);
crop_data *crop;
// sanity
if (crop_proto(vnum)) {
log("SYSERR: Attempting to insert crop at existing vnum %d", vnum);
return crop_proto(vnum);
}
CREATE(crop, crop_data, 1);
init_crop(crop);
GET_CROP_VNUM(crop) = vnum;
add_crop_to_table(crop);
// save index and crop file now
save_index(DB_BOOT_CROP);
save_library_file_for_vnum(DB_BOOT_CROP, vnum);
return crop;
}
/**
* Creates a new craft table entry.
*
* @param craft_vnum vnum The number to create.
* @return craft_data* The new recipe's prototypes.
*/
craft_data *create_craft_table_entry(craft_vnum vnum) {
void add_craft_to_table(craft_data *craft);
craft_data *craft;
// sanity
if (craft_proto(vnum)) {
log("SYSERR: Attempting to insert craft at existing vnum %d", vnum);
return craft_proto(vnum);
}
CREATE(craft, craft_data, 1);
init_craft(craft);
GET_CRAFT_VNUM(craft) = vnum;
add_craft_to_table(craft);
// save index and craft file now
save_index(DB_BOOT_CRAFT);
save_library_file_for_vnum(DB_BOOT_CRAFT, vnum);
return craft;
}
/**
* Creates a new building entry.
*
* @param bld_vnum vnum The number to create.
* @return bld_data *The new building's prototype.
*/
bld_data *create_building_table_entry(bld_vnum vnum) {
void add_building_to_table(bld_data *bld);
bld_data *bld;
// sanity
if (building_proto(vnum)) {
log("SYSERR: Attempting to insert building at existing vnum %d", vnum);
return building_proto(vnum);
}
CREATE(bld, bld_data, 1);
init_building(bld);
GET_BLD_VNUM(bld) = vnum;
add_building_to_table(bld);
// save index and building file now
save_index(DB_BOOT_BLD);
save_library_file_for_vnum(DB_BOOT_BLD, vnum);
return bld;
}
/**
* Creates a new mob entry.
*
* @param mob_vnum vnum The number to create.
* @return char_data* The new mob's prototype.
*/
char_data *create_mob_table_entry(mob_vnum vnum) {
void add_mobile_to_table(char_data *mob);
char_data *mob;
// sanity
if (mob_proto(vnum)) {
log("SYSERR: Attempting to insert mobile at existing vnum %d", vnum);
return mob_proto(vnum);
}
CREATE(mob, char_data, 1);
clear_char(mob);
mob->vnum = vnum;
SET_BIT(MOB_FLAGS(mob), MOB_ISNPC); // need this for some macroes
add_mobile_to_table(mob);
// save mob index and mob file now so there's no trouble later
save_index(DB_BOOT_MOB);
save_library_file_for_vnum(DB_BOOT_MOB, vnum);
return mob;
}
/**
* WARNING: This function actually deletes a craft recipe.
*
* @param char_data *ch The person doing the deleting.
* @param craft_vnum vnum The vnum to delete.
*/
void olc_delete_craft(char_data *ch, craft_vnum vnum) {
void cancel_gen_craft(char_data *ch);
void remove_craft_from_table(craft_data *craft);
craft_data *craft;
char_data *iter;
if (!(craft = craft_proto(vnum))) {
msg_to_char(ch, "There is no such craft %d.\r\n", vnum);
return;
}
if (HASH_COUNT(craft_table) <= 1) {
msg_to_char(ch, "You can't delete the last craft.\r\n");
return;
}
// find players who are crafting it and stop them (BEFORE removing from table)
for (iter = character_list; iter; iter = iter->next) {
if (!IS_NPC(iter) && GET_ACTION(iter) == ACT_GEN_CRAFT && GET_ACTION_VNUM(iter, 0) == GET_CRAFT_VNUM(craft)) {
msg_to_char(iter, "The craft you were making has been deleted.\r\n");
cancel_gen_craft(iter);
}
}
// remove from table -- nothing else to check here
remove_craft_from_table(craft);
// save index and craft file now
save_index(DB_BOOT_CRAFT);
save_library_file_for_vnum(DB_BOOT_CRAFT, vnum);
syslog(SYS_OLC, GET_INVIS_LEV(ch), TRUE, "OLC: %s has deleted craft recipe %d", GET_NAME(ch), vnum);
msg_to_char(ch, "Craft recipe %d deleted.\r\n", vnum);
free_craft(craft);
}
int MAIN(int argc, char **argv)
{
int add_user = 0;
int list_user= 0;
int delete_user= 0;
int modify_user= 0;
char * user = NULL;
char *passargin = NULL, *passargout = NULL;
char *passin = NULL, *passout = NULL;
char * gN = NULL;
int gNindex = -1;
char ** gNrow = NULL;
int maxgN = -1;
char * userinfo = NULL;
int badops=0;
int ret=1;
int errors=0;
int verbose=0;
int doupdatedb=0;
char *configfile=NULL;
char *dbfile=NULL;
CA_DB *db=NULL;
char **pp ;
int i;
long errorline = -1;
char *randfile=NULL;
#ifndef OPENSSL_NO_ENGINE
char *engine = NULL;
#endif
char *tofree=NULL;
DB_ATTR db_attr;
#ifdef EFENCE
EF_PROTECT_FREE=1;
EF_PROTECT_BELOW=1;
EF_ALIGNMENT=0;
#endif
apps_startup();
conf = NULL;
section = NULL;
if (bio_err == NULL)
if ((bio_err=BIO_new(BIO_s_file())) != NULL)
BIO_set_fp(bio_err,stderr,BIO_NOCLOSE|BIO_FP_TEXT);
argc--;
argv++;
while (argc >= 1 && badops == 0)
{
if (strcmp(*argv,"-verbose") == 0)
verbose++;
else if (strcmp(*argv,"-config") == 0)
{
if (--argc < 1) goto bad;
configfile= *(++argv);
}
else if (strcmp(*argv,"-name") == 0)
{
if (--argc < 1) goto bad;
section= *(++argv);
}
else if (strcmp(*argv,"-srpvfile") == 0)
{
if (--argc < 1) goto bad;
dbfile= *(++argv);
}
else if (strcmp(*argv,"-add") == 0)
add_user=1;
else if (strcmp(*argv,"-delete") == 0)
delete_user=1;
else if (strcmp(*argv,"-modify") == 0)
modify_user=1;
else if (strcmp(*argv,"-list") == 0)
list_user=1;
else if (strcmp(*argv,"-gn") == 0)
{
if (--argc < 1) goto bad;
gN= *(++argv);
}
else if (strcmp(*argv,"-userinfo") == 0)
{
if (--argc < 1) goto bad;
userinfo= *(++argv);
}
else if (strcmp(*argv,"-passin") == 0)
{
if (--argc < 1) goto bad;
passargin= *(++argv);
}
else if (strcmp(*argv,"-passout") == 0)
{
if (--argc < 1) goto bad;
passargout= *(++argv);
}
#ifndef OPENSSL_NO_ENGINE
else if (strcmp(*argv,"-engine") == 0)
{
if (--argc < 1) goto bad;
engine= *(++argv);
}
#endif
else if (**argv == '-')
{
bad:
BIO_printf(bio_err,"unknown option %s\n",*argv);
badops=1;
break;
}
else
break;
argc--;
argv++;
}
if (dbfile && configfile)
{
BIO_printf(bio_err,"-dbfile and -configfile cannot be specified together.\n");
badops = 1;
}
if (add_user+delete_user+modify_user+list_user != 1)
{
BIO_printf(bio_err,"Exactly one of the options -add, -delete, -modify -list must be specified.\n");
badops = 1;
}
if (delete_user+modify_user+delete_user== 1 && argc <= 0)
{
BIO_printf(bio_err,"Need at least one user for options -add, -delete, -modify. \n");
badops = 1;
}
if ((passin || passout) && argc != 1 )
{
BIO_printf(bio_err,"-passin, -passout arguments only valid with one user.\n");
badops = 1;
}
if (badops)
{
for (pp=srp_usage; (*pp != NULL); pp++)
BIO_printf(bio_err,"%s",*pp);
BIO_printf(bio_err," -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR, LIST_SEPARATOR_CHAR);
BIO_printf(bio_err," load the file (or the files in the directory) into\n");
BIO_printf(bio_err," the random number generator\n");
goto err;
}
ERR_load_crypto_strings();
#ifndef OPENSSL_NO_ENGINE
setup_engine(bio_err, engine, 0);
#endif
if(!app_passwd(bio_err, passargin, passargout, &passin, &passout))
{
BIO_printf(bio_err, "Error getting passwords\n");
goto err;
}
if (!dbfile)
{
/*****************************************************************/
tofree=NULL;
if (configfile == NULL) configfile = getenv("OPENSSL_CONF");
if (configfile == NULL) configfile = getenv("SSLEAY_CONF");
if (configfile == NULL)
{
const char *s=X509_get_default_cert_area();
size_t len;
#ifdef OPENSSL_SYS_VMS
len = strlen(s)+sizeof(CONFIG_FILE);
tofree=OPENSSL_malloc(len);
strcpy(tofree,s);
#else
len = strlen(s)+sizeof(CONFIG_FILE)+1;
tofree=OPENSSL_malloc(len);
BUF_strlcpy(tofree,s,len);
BUF_strlcat(tofree,"/",len);
#endif
BUF_strlcat(tofree,CONFIG_FILE,len);
configfile=tofree;
}
VERBOSE BIO_printf(bio_err,"Using configuration from %s\n",configfile);
conf = NCONF_new(NULL);
if (NCONF_load(conf,configfile,&errorline) <= 0)
{
if (errorline <= 0)
BIO_printf(bio_err,"error loading the config file '%s'\n",
configfile);
else
BIO_printf(bio_err,"error on line %ld of config file '%s'\n"
,errorline,configfile);
goto err;
}
if(tofree)
{
OPENSSL_free(tofree);
tofree = NULL;
}
if (!load_config(bio_err, conf))
goto err;
/* Lets get the config section we are using */
if (section == NULL)
{
VERBOSE BIO_printf(bio_err,"trying to read " ENV_DEFAULT_SRP " in \" BASE_SECTION \"\n");
section=NCONF_get_string(conf,BASE_SECTION,ENV_DEFAULT_SRP);
if (section == NULL)
{
lookup_fail(BASE_SECTION,ENV_DEFAULT_SRP);
goto err;
}
}
if (randfile == NULL && conf)
randfile = NCONF_get_string(conf, BASE_SECTION, "RANDFILE");
VERBOSE BIO_printf(bio_err,"trying to read " ENV_DATABASE " in section \"%s\"\n",section);
if ((dbfile=NCONF_get_string(conf,section,ENV_DATABASE)) == NULL)
{
lookup_fail(section,ENV_DATABASE);
goto err;
}
}
if (randfile == NULL)
ERR_clear_error();
else
app_RAND_load_file(randfile, bio_err, 0);
VERBOSE BIO_printf(bio_err,"Trying to read SRP verifier file \"%s\"\n",dbfile);
db = load_index(dbfile, &db_attr);
if (db == NULL) goto err;
/* Lets check some fields */
for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++)
{
pp = sk_OPENSSL_PSTRING_value(db->db->data, i);
if (pp[DB_srptype][0] == DB_SRP_INDEX)
{
maxgN = i;
if (gNindex < 0 && gN != NULL && !strcmp(gN, pp[DB_srpid]))
gNindex = i;
print_index(db, bio_err, i, verbose > 1);
}
}
VERBOSE BIO_printf(bio_err, "Database initialised\n");
if (gNindex >= 0)
{
gNrow = sk_OPENSSL_PSTRING_value(db->db->data,gNindex);
print_entry(db, bio_err, gNindex, verbose > 1, "Default g and N");
}
else if (maxgN > 0 && !SRP_get_default_gN(gN))
{
BIO_printf(bio_err, "No g and N value for index \"%s\"\n", gN);
goto err;
}
else
{
VERBOSE BIO_printf(bio_err, "Database has no g N information.\n");
gNrow = NULL;
}
VVERBOSE BIO_printf(bio_err,"Starting user processing\n");
if (argc > 0)
user = *(argv++) ;
while (list_user || user)
{
int userindex = -1;
if (user)
VVERBOSE BIO_printf(bio_err, "Processing user \"%s\"\n", user);
if ((userindex = get_index(db, user, 'U')) >= 0)
{
print_user(db, bio_err, userindex, (verbose > 0) || list_user);
}
if (list_user)
{
if (user == NULL)
{
BIO_printf(bio_err,"List all users\n");
for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++)
{
print_user(db,bio_err, i, 1);
}
list_user = 0;
}
else if (userindex < 0)
{
BIO_printf(bio_err, "user \"%s\" does not exist, ignored. t\n",
user);
errors++;
}
}
else if (add_user)
{
if (userindex >= 0)
{
/* reactivation of a new user */
char **row = sk_OPENSSL_PSTRING_value(db->db->data, userindex);
BIO_printf(bio_err, "user \"%s\" reactivated.\n", user);
row[DB_srptype][0] = 'V';
doupdatedb = 1;
}
else
{
char *row[DB_NUMBER] ; char *gNid;
row[DB_srpverifier] = NULL;
row[DB_srpsalt] = NULL;
row[DB_srpinfo] = NULL;
if (!(gNid = srp_create_user(user,&(row[DB_srpverifier]), &(row[DB_srpsalt]),gNrow?gNrow[DB_srpsalt]:gN,gNrow?gNrow[DB_srpverifier]:NULL, passout, bio_err,verbose)))
{
BIO_printf(bio_err, "Cannot create srp verifier for user \"%s\", operation abandoned .\n", user);
errors++;
goto err;
}
row[DB_srpid] = BUF_strdup(user);
row[DB_srptype] = BUF_strdup("v");
row[DB_srpgN] = BUF_strdup(gNid);
if (!row[DB_srpid] || !row[DB_srpgN] || !row[DB_srptype] || !row[DB_srpverifier] || !row[DB_srpsalt] ||
(userinfo && (!(row[DB_srpinfo] = BUF_strdup(userinfo)))) ||
!update_index(db, bio_err, row))
{
if (row[DB_srpid]) OPENSSL_free(row[DB_srpid]);
if (row[DB_srpgN]) OPENSSL_free(row[DB_srpgN]);
if (row[DB_srpinfo]) OPENSSL_free(row[DB_srpinfo]);
if (row[DB_srptype]) OPENSSL_free(row[DB_srptype]);
if (row[DB_srpverifier]) OPENSSL_free(row[DB_srpverifier]);
if (row[DB_srpsalt]) OPENSSL_free(row[DB_srpsalt]);
goto err;
}
doupdatedb = 1;
}
}
else if (modify_user)
{
if (userindex < 0)
{
BIO_printf(bio_err,"user \"%s\" does not exist, operation ignored.\n",user);
errors++;
}
else
{
char **row = sk_OPENSSL_PSTRING_value(db->db->data, userindex);
char type = row[DB_srptype][0];
if (type == 'v')
{
BIO_printf(bio_err,"user \"%s\" already updated, operation ignored.\n",user);
errors++;
}
else
{
char *gNid;
if (row[DB_srptype][0] == 'V')
{
int user_gN;
char **irow = NULL;
VERBOSE BIO_printf(bio_err,"Verifying password for user \"%s\"\n",user);
if ( (user_gN = get_index(db, row[DB_srpgN], DB_SRP_INDEX)) >= 0)
irow = (char **)sk_OPENSSL_PSTRING_value(db->db->data, userindex);
if (!srp_verify_user(user, row[DB_srpverifier], row[DB_srpsalt], irow ? irow[DB_srpsalt] : row[DB_srpgN], irow ? irow[DB_srpverifier] : NULL, passin, bio_err, verbose))
{
BIO_printf(bio_err, "Invalid password for user \"%s\", operation abandoned.\n", user);
errors++;
goto err;
}
}
VERBOSE BIO_printf(bio_err,"Password for user \"%s\" ok.\n",user);
if (!(gNid=srp_create_user(user,&(row[DB_srpverifier]), &(row[DB_srpsalt]),gNrow?gNrow[DB_srpsalt]:NULL, gNrow?gNrow[DB_srpverifier]:NULL, passout, bio_err,verbose)))
{
BIO_printf(bio_err, "Cannot create srp verifier for user \"%s\", operation abandoned.\n", user);
errors++;
goto err;
}
row[DB_srptype][0] = 'v';
row[DB_srpgN] = BUF_strdup(gNid);
if (!row[DB_srpid] || !row[DB_srpgN] || !row[DB_srptype] || !row[DB_srpverifier] || !row[DB_srpsalt] ||
(userinfo && (!(row[DB_srpinfo] = BUF_strdup(userinfo)))))
goto err;
doupdatedb = 1;
}
}
}
else if (delete_user)
{
if (userindex < 0)
{
BIO_printf(bio_err, "user \"%s\" does not exist, operation ignored. t\n", user);
errors++;
}
else
{
char **xpp = sk_OPENSSL_PSTRING_value(db->db->data,userindex);
BIO_printf(bio_err, "user \"%s\" revoked. t\n", user);
xpp[DB_srptype][0] = 'R';
doupdatedb = 1;
}
}
if (--argc > 0)
user = *(argv++) ;
else
{
user = NULL;
list_user = 0;
}
}
VERBOSE BIO_printf(bio_err,"User procession done.\n");
if (doupdatedb)
{
/* Lets check some fields */
for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++)
{
pp = sk_OPENSSL_PSTRING_value(db->db->data,i);
if (pp[DB_srptype][0] == 'v')
{
pp[DB_srptype][0] = 'V';
print_user(db, bio_err, i, verbose);
}
}
VERBOSE BIO_printf(bio_err, "Trying to update srpvfile.\n");
if (!save_index(dbfile, "new", db)) goto err;
VERBOSE BIO_printf(bio_err, "Temporary srpvfile created.\n");
if (!rotate_index(dbfile, "new", "old")) goto err;
VERBOSE BIO_printf(bio_err, "srpvfile updated.\n");
}
ret = (errors != 0);
err:
if (errors != 0)
VERBOSE BIO_printf(bio_err,"User errors %d.\n",errors);
VERBOSE BIO_printf(bio_err,"SRP terminating with code %d.\n",ret);
if(tofree)
OPENSSL_free(tofree);
if (ret) ERR_print_errors(bio_err);
if (randfile) app_RAND_write_file(randfile, bio_err);
if (conf) NCONF_free(conf);
if (db) free_index(db);
OBJ_cleanup();
apps_shutdown();
OPENSSL_EXIT(ret);
}
int main(int argc, char *argv[]) {
char *infile, *outfile;
uchar *text;
ulong text_len;
void *index;
int error;
if (argc < 3) print_usage(argv[0]);
infile = argv[1]; // input file
outfile = argv[2]; // output file
error = read_file(infile, &text, &text_len);
IFERROR(error);
/* Possible options:
"-a x": indicates the behaviour of FM-index with the pointer 'text'.
x == 0 FM-index uses 'text' directly to build the suffix array.
This means that you are responsable to allocate 'length+overshoot'
bytes for the text instead of 'length' bytes. You must include
ds_ssort.h. See function read_file();
x == 1 FM-index frees the allocated memory for the 'text'. overshoot
and ds_ssort.h are not necessary.
x == 2 FM-index makes its internal copy of 'text'. After the call,
'text' is available. overshoot and ds_ssort.h are not
necessary.
-B Bsize: where Bsize is the size in Kbytes of level 1 buckets.
-b bsize: where bsize is the size in bytes of level 2 buckets.
bsize must divide Bsize*1024;
-f frequency: where frequency is a number from 0 to 1 that indicates the
frequency of the marked characters.
default "-b 512 -B 16 -f 0.02 -a 1"
Example of some call to build_index():
- build_index(text, text_len, NULL, &index);
uses the default parameters.
- build_index(text, text_len, "-a 1 -f 0.1", &index);
tries to mark 10% of the positions instead of 2% but I cannot reuse 'text'
after this call.
*/
fprintf(stdout, "Building\n");
error = build_index(text, text_len, "-a 1", &index);
IFERROR(error);
ulong index_len;
index_size(index, &index_len);
fprintf(stdout,"Input: %lu bytes --> Output %lu bytes.\n", text_len, index_len);
fprintf(stdout,"Overall compression --> %.2f%% (%.2f bits per char).\n\n",
(100.0*index_len)/text_len, (index_len*8.0)/text_len);
uchar *snippet;
ulong i, readen, from = 11, to = 100, numocc, *occ;
error = extract(index, from, to, &snippet, &readen);
IFERROR(error);
fprintf(stdout, "try extract\n\n");
for(i=0;i<readen;i++)
printf("%c", snippet[i]);
printf("\n");
uchar *pattern = snippet;
fprintf(stdout, "try count\n\n");
error = count (index, pattern, 5, &numocc);
printf("pattern: ");
fwrite(pattern, sizeof(uchar), 5, stdout);
printf(" # occs %lu\n\n",numocc);
fprintf(stdout, "try locate\n\n");
error = locate (index, pattern, 5, &occ, &numocc);
IFERROR (error);
for(i=0;i<numocc;i++)
printf("pos %lu\n", occ[i]);
printf("\n");
free(snippet);
if(numocc) free(occ);
error = save_index(index, outfile);
IFERROR(error);
error = free_index(index);
IFERROR(error);
exit(0);
}
int srp_main(int argc, char **argv)
{
CA_DB *db = NULL;
CONF *conf = NULL;
int gNindex = -1, maxgN = -1, ret = 1, errors = 0, verbose = 0, i;
int doupdatedb = 0, mode = OPT_ERR;
char *user = NULL, *passinarg = NULL, *passoutarg = NULL;
char *passin = NULL, *passout = NULL, *gN = NULL, *userinfo = NULL;
char *randfile = NULL, *section = NULL;
char **gNrow = NULL, *configfile = NULL;
char *srpvfile = NULL, **pp, *prog;
OPTION_CHOICE o;
prog = opt_init(argc, argv, srp_options);
while ((o = opt_next()) != OPT_EOF) {
switch (o) {
case OPT_EOF:
case OPT_ERR:
opthelp:
BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
goto end;
case OPT_HELP:
opt_help(srp_options);
ret = 0;
goto end;
case OPT_VERBOSE:
verbose++;
break;
case OPT_CONFIG:
configfile = opt_arg();
break;
case OPT_NAME:
section = opt_arg();
break;
case OPT_SRPVFILE:
srpvfile = opt_arg();
break;
case OPT_ADD:
case OPT_DELETE:
case OPT_MODIFY:
case OPT_LIST:
if (mode != OPT_ERR) {
BIO_printf(bio_err,
"%s: Only one of -add/delete-modify/-list\n",
prog);
goto opthelp;
}
mode = o;
break;
case OPT_GN:
gN = opt_arg();
break;
case OPT_USERINFO:
userinfo = opt_arg();
break;
case OPT_PASSIN:
passinarg = opt_arg();
break;
case OPT_PASSOUT:
passoutarg = opt_arg();
break;
case OPT_ENGINE:
(void)setup_engine(opt_arg(), 0);
break;
}
}
argc = opt_num_rest();
argv = opt_rest();
if (srpvfile && configfile) {
BIO_printf(bio_err,
"-srpvfile and -configfile cannot be specified together.\n");
goto end;
}
if (mode == OPT_ERR) {
BIO_printf(bio_err,
"Exactly one of the options -add, -delete, -modify -list must be specified.\n");
goto opthelp;
}
if ((mode == OPT_DELETE || mode == OPT_MODIFY || mode == OPT_ADD)
&& argc < 1) {
BIO_printf(bio_err,
"Need at least one user for options -add, -delete, -modify. \n");
goto opthelp;
}
if ((passin || passout) && argc != 1) {
BIO_printf(bio_err,
"-passin, -passout arguments only valid with one user.\n");
goto opthelp;
}
if (!app_passwd(passinarg, passoutarg, &passin, &passout)) {
BIO_printf(bio_err, "Error getting passwords\n");
goto end;
}
if (!srpvfile) {
if (!configfile)
configfile = default_config_file;
if (verbose)
BIO_printf(bio_err, "Using configuration from %s\n",
configfile);
conf = app_load_config(configfile);
if (conf == NULL)
goto end;
if (configfile != default_config_file && !app_load_modules(conf))
goto end;
/* Lets get the config section we are using */
if (section == NULL) {
if (verbose)
BIO_printf(bio_err,
"trying to read " ENV_DEFAULT_SRP
" in " BASE_SECTION "\n");
section = lookup_conf(conf, BASE_SECTION, ENV_DEFAULT_SRP);
if (section == NULL)
goto end;
}
if (randfile == NULL)
randfile = NCONF_get_string(conf, BASE_SECTION, "RANDFILE");
if (verbose)
BIO_printf(bio_err,
"trying to read " ENV_DATABASE " in section \"%s\"\n",
section);
srpvfile = lookup_conf(conf, section, ENV_DATABASE);
if (srpvfile == NULL)
goto end;
}
if (randfile == NULL)
ERR_clear_error();
else
app_RAND_load_file(randfile, 0);
if (verbose)
BIO_printf(bio_err, "Trying to read SRP verifier file \"%s\"\n",
srpvfile);
db = load_index(srpvfile, NULL);
if (db == NULL)
goto end;
/* Lets check some fields */
for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {
pp = sk_OPENSSL_PSTRING_value(db->db->data, i);
if (pp[DB_srptype][0] == DB_SRP_INDEX) {
maxgN = i;
if ((gNindex < 0) && (gN != NULL) && strcmp(gN, pp[DB_srpid]) == 0)
gNindex = i;
print_index(db, i, verbose > 1);
}
}
if (verbose)
BIO_printf(bio_err, "Database initialised\n");
if (gNindex >= 0) {
gNrow = sk_OPENSSL_PSTRING_value(db->db->data, gNindex);
print_entry(db, gNindex, verbose > 1, "Default g and N");
} else if (maxgN > 0 && !SRP_get_default_gN(gN)) {
BIO_printf(bio_err, "No g and N value for index \"%s\"\n", gN);
goto end;
} else {
if (verbose)
BIO_printf(bio_err, "Database has no g N information.\n");
gNrow = NULL;
}
if (verbose > 1)
BIO_printf(bio_err, "Starting user processing\n");
if (argc > 0)
user = *(argv++);
while (mode == OPT_LIST || user) {
int userindex = -1;
if (user != NULL && verbose > 1)
BIO_printf(bio_err, "Processing user \"%s\"\n", user);
if ((userindex = get_index(db, user, 'U')) >= 0) {
print_user(db, userindex, (verbose > 0) || mode == OPT_LIST);
}
if (mode == OPT_LIST) {
if (user == NULL) {
BIO_printf(bio_err, "List all users\n");
for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {
print_user(db, i, 1);
}
} else if (userindex < 0) {
BIO_printf(bio_err,
"user \"%s\" does not exist, ignored. t\n", user);
errors++;
}
} else if (mode == OPT_ADD) {
if (userindex >= 0) {
/* reactivation of a new user */
char **row =
sk_OPENSSL_PSTRING_value(db->db->data, userindex);
BIO_printf(bio_err, "user \"%s\" reactivated.\n", user);
row[DB_srptype][0] = 'V';
doupdatedb = 1;
} else {
char *row[DB_NUMBER];
char *gNid;
row[DB_srpverifier] = NULL;
row[DB_srpsalt] = NULL;
row[DB_srpinfo] = NULL;
if (!
(gNid =
srp_create_user(user, &(row[DB_srpverifier]),
&(row[DB_srpsalt]),
gNrow ? gNrow[DB_srpsalt] : gN,
gNrow ? gNrow[DB_srpverifier] : NULL,
passout, verbose))) {
BIO_printf(bio_err,
"Cannot create srp verifier for user \"%s\", operation abandoned .\n",
user);
errors++;
goto end;
}
row[DB_srpid] = OPENSSL_strdup(user);
row[DB_srptype] = OPENSSL_strdup("v");
row[DB_srpgN] = OPENSSL_strdup(gNid);
if ((row[DB_srpid] == NULL)
|| (row[DB_srpgN] == NULL)
|| (row[DB_srptype] == NULL)
|| (row[DB_srpverifier] == NULL)
|| (row[DB_srpsalt] == NULL)
|| (userinfo
&& ((row[DB_srpinfo] = OPENSSL_strdup(userinfo)) == NULL))
|| !update_index(db, row)) {
OPENSSL_free(row[DB_srpid]);
OPENSSL_free(row[DB_srpgN]);
OPENSSL_free(row[DB_srpinfo]);
OPENSSL_free(row[DB_srptype]);
OPENSSL_free(row[DB_srpverifier]);
OPENSSL_free(row[DB_srpsalt]);
goto end;
}
doupdatedb = 1;
}
} else if (mode == OPT_MODIFY) {
if (userindex < 0) {
BIO_printf(bio_err,
"user \"%s\" does not exist, operation ignored.\n",
user);
errors++;
} else {
char **row =
sk_OPENSSL_PSTRING_value(db->db->data, userindex);
char type = row[DB_srptype][0];
if (type == 'v') {
BIO_printf(bio_err,
"user \"%s\" already updated, operation ignored.\n",
user);
errors++;
} else {
char *gNid;
if (row[DB_srptype][0] == 'V') {
int user_gN;
char **irow = NULL;
if (verbose)
BIO_printf(bio_err,
"Verifying password for user \"%s\"\n",
user);
if ((user_gN =
get_index(db, row[DB_srpgN], DB_SRP_INDEX)) >= 0)
irow =
sk_OPENSSL_PSTRING_value(db->db->data,
userindex);
if (!srp_verify_user
(user, row[DB_srpverifier], row[DB_srpsalt],
irow ? irow[DB_srpsalt] : row[DB_srpgN],
irow ? irow[DB_srpverifier] : NULL, passin,
verbose)) {
BIO_printf(bio_err,
"Invalid password for user \"%s\", operation abandoned.\n",
user);
errors++;
goto end;
}
}
if (verbose)
BIO_printf(bio_err, "Password for user \"%s\" ok.\n",
user);
if (!
(gNid =
srp_create_user(user, &(row[DB_srpverifier]),
&(row[DB_srpsalt]),
gNrow ? gNrow[DB_srpsalt] : NULL,
gNrow ? gNrow[DB_srpverifier] : NULL,
passout, verbose))) {
BIO_printf(bio_err,
"Cannot create srp verifier for user \"%s\", operation abandoned.\n",
user);
errors++;
goto end;
}
row[DB_srptype][0] = 'v';
row[DB_srpgN] = OPENSSL_strdup(gNid);
if (row[DB_srpid] == NULL
|| row[DB_srpgN] == NULL
|| row[DB_srptype] == NULL
|| row[DB_srpverifier] == NULL
|| row[DB_srpsalt] == NULL
|| (userinfo
&& ((row[DB_srpinfo] = OPENSSL_strdup(userinfo))
== NULL)))
goto end;
doupdatedb = 1;
}
}
} else if (mode == OPT_DELETE) {
if (userindex < 0) {
BIO_printf(bio_err,
"user \"%s\" does not exist, operation ignored. t\n",
user);
errors++;
} else {
char **xpp = sk_OPENSSL_PSTRING_value(db->db->data, userindex);
BIO_printf(bio_err, "user \"%s\" revoked. t\n", user);
xpp[DB_srptype][0] = 'R';
doupdatedb = 1;
}
}
if (--argc > 0)
user = *(argv++);
else {
user = NULL;
}
}
if (verbose)
BIO_printf(bio_err, "User procession done.\n");
if (doupdatedb) {
/* Lets check some fields */
for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {
pp = sk_OPENSSL_PSTRING_value(db->db->data, i);
if (pp[DB_srptype][0] == 'v') {
pp[DB_srptype][0] = 'V';
print_user(db, i, verbose);
}
}
if (verbose)
BIO_printf(bio_err, "Trying to update srpvfile.\n");
if (!save_index(srpvfile, "new", db))
goto end;
if (verbose)
BIO_printf(bio_err, "Temporary srpvfile created.\n");
if (!rotate_index(srpvfile, "new", "old"))
goto end;
if (verbose)
BIO_printf(bio_err, "srpvfile updated.\n");
}
ret = (errors != 0);
end:
if (errors != 0)
if (verbose)
BIO_printf(bio_err, "User errors %d.\n", errors);
if (verbose)
BIO_printf(bio_err, "SRP terminating with code %d.\n", ret);
OPENSSL_free(passin);
OPENSSL_free(passout);
if (ret)
ERR_print_errors(bio_err);
if (randfile)
app_RAND_write_file(randfile);
NCONF_free(conf);
free_index(db);
return (ret);
}
int command_line_function(void)
{
int retval = 0;
start_timer();
if( flag_efficiency_debug )
efficiency_init();
if( input_file == NULL )
{
init_database();
load_phashes();
for( int f=0; f < flag_load_multiple_times; f++ )
load_phashes();
unsigned long long seed = 0x3333CCCCCCCC3333;
master_tree = index_phashes(master_tree,&master_list,NULL,seed,0);
}
else
{
master_tree = load_index(input_file);
}
load_time = stop_timer();
double total_query_time = 0;
if( num_pthreads > num_phash_queries )
num_pthreads = num_phash_queries;
struct threaded_query_pkg *packages[num_phash_queries];
pthread_t threads[num_pthreads];
int threads_running = 0;
int q = num_phash_queries;
pthread_t *current_thread = threads;
int query_num = 1;
int join_count = 0;
while(q--)
{
packages[q] = (struct threaded_query_pkg*)malloc(sizeof(struct threaded_query_pkg));
packages[q]->done = 0;
packages[q]->query_num = query_num;
packages[q]->query = phash_queries[q];
debugp( 3, "Launching thread #%d (%d running)\n", q, threads_running );
pthread_create( &(*current_thread), NULL, &threaded_query, (void*)packages[q] );
query_num++;
threads_running++;
current_thread++;
if( (current_thread - threads) >= num_pthreads )
{
current_thread = threads;
}
if( threads_running >= num_pthreads )
{
pthread_join( *current_thread, NULL );
join_count++;
threads_running--;
}
}
for( int t = 0; t < num_pthreads; t++ )
{
pthread_join( threads[t], NULL );
}
for( q=0; q < num_phash_queries; q++ )
{
total_query_time += packages[q]->query_time;
debugp( 1, "Query #%d: phash = 0x%llX d <= %d] (%f sec) \n", q+1, packages[q]->query, query_max_distance, packages[q]->query_time );
debugp( 2, "packages[%d]->matches is at %p\n", q, packages[q]->matches );
if(packages[q]->matches != NULL)
debugp( 2, "packages[%d]->matches->count = %d\n", q, packages[q]->matches->count );
if( (packages[q]->matches != NULL) && (packages[q]->matches->count) )
{
for( int m=0; m < packages[q]->matches->count; m++ )
{
debugp( 1, " Match #%d: 0x%llX (d=%d)\n",
m+1,
packages[q]->matches->matches[m].phash,
packages[q]->matches->matches[m].dist );
if( flag_php )
{
printf( "%llX\n", packages[q]->matches->matches[m].phash );
}
}
}
else
{
debugp( 1, " ** No Matches **\n" );
}
debugp( 2, "packages[%d]->done = %d\n", q, packages[q]->done );
if(packages[q]->matches != NULL)
free(packages[q]->matches->matches);
free(packages[q]->matches);
free(packages[q]);
}
double avg_query_time = total_query_time / (double)num_phash_queries;
if( logfile_name != NULL )
{
FILE *fp;
if( (fp = fopen( logfile_name, "a" )) )
{
char buffer[512];
sprintf( buffer, "%d,%f,%f\n", num_phash_queries,avg_query_time,total_query_time );
fwrite( buffer, sizeof(char), strlen(buffer), fp );
}
fclose(fp);
}
if( input_file == NULL )
deinit_database();
if( flag_print_vp_tree )
{
print_vp_tree(master_tree);
size_t size = get_recursive_node_size(master_tree);
debugp( 1, "Total size: %d bytes\n", size );
}
if( output_file != NULL )
save_index( master_tree, output_file );
if( flag_efficiency_debug )
print_efficiency_summary();
free_vp_tree(master_tree);
return retval;
}
/**
* WARNING: This function actually deletes a building.
*
* @param char_data *ch The person doing the deleting.
* @param bld_vnum vnum The vnum to delete.
*/
void olc_delete_building(char_data *ch, bld_vnum vnum) {
void check_for_bad_buildings();
extern bool delete_link_rule_by_type_value(struct adventure_link_rule **list, int type, any_vnum value);
void remove_building_from_table(bld_data *bld);
descriptor_data *desc;
room_data *room, *next_room;
craft_data *craft, *next_craft;
adv_data *adv, *next_adv;
bld_data *bld;
int count;
bool found, deleted = FALSE;
if (!(bld = building_proto(vnum))) {
msg_to_char(ch, "There is no such building %d.\r\n", vnum);
return;
}
if (HASH_COUNT(building_table) <= 1) {
msg_to_char(ch, "You can't delete the last building.\r\n");
return;
}
// pull from hash
remove_building_from_table(bld);
// save index and building file now
save_index(DB_BOOT_BLD);
save_library_file_for_vnum(DB_BOOT_BLD, vnum);
// update world
count = 0;
HASH_ITER(world_hh, world_table, room, next_room) {
if (IS_ANY_BUILDING(room) && BUILDING_VNUM(room) == vnum) {
if (GET_ROOM_VNUM(room) >= MAP_SIZE) {
delete_room(room, FALSE); // must call check_all_exits
deleted = TRUE;
}
else {
// map room
if (ROOM_PEOPLE(room)) {
act("The building has been deleted.", FALSE, ROOM_PEOPLE(room), NULL, NULL, TO_CHAR | TO_ROOM);
}
disassociate_building(room);
}
}
}
if (deleted) {
check_all_exits();
}
// adventure zones
HASH_ITER(hh, adventure_table, adv, next_adv) {
found = delete_link_rule_by_type_value(&GET_ADV_LINKING(adv), ADV_LINK_BUILDING_EXISTING, vnum);
found |= delete_link_rule_by_type_value(&GET_ADV_LINKING(adv), ADV_LINK_BUILDING_NEW, vnum);
found |= delete_link_rule_by_type_value(&GET_ADV_LINKING(adv), ADV_LINK_PORTAL_BUILDING_EXISTING, vnum);
found |= delete_link_rule_by_type_value(&GET_ADV_LINKING(adv), ADV_LINK_PORTAL_BUILDING_NEW, vnum);
if (found) {
save_library_file_for_vnum(DB_BOOT_ADV, GET_ADV_VNUM(adv));
}
}
