int main(void)
{
char str[10] = "food fool\0";
printf("Original string: %s\n", str);
censor(str);
printf("Censored string: %s\n", str);
return 0;
}
int main(void)
{
char s[] = "food fool.";
censor(s);
puts(s);
return 0;
}
int main(void)
{
char rep_str[N];
int n;
printf("Enter something: ");
n = read_line(rep_str, N);
censor(rep_str);
printf("%s\n", rep_str);
return 0;
}
void initstr(char badword[MAXLENGTH], int badwlen)
{
FILE *file;
file = fopen("badwords", "r");
char line[MAXLENGTH];
int len;
while (fgets(line, MAXLENGTH, file)) {
// El -2 al final es para eliminar los últimos dos carácteres que deja fgets()
len = strnlen(line, MAXLENGTH) - 2;
line[len] = '\0';
/* Compara las dos strings, sin importar si están en mayúsculas o minúsculas */
if ((strncasecmp(line, badword, MAXLENGTH)) == 0) {
censor(badword, badwlen);
printf("%s\n", badword);
break;
}
}
fclose(file);
}
bool Filter::censor(const char* source, int length) {
std::string ___source;
___source.assign(source, length);
return censor(___source);
}
dmessage(char *message, unsigned char flags, unsigned char from, unsigned char to)
{
register int len;
W_Color color;
char timebuf[10];
LONG curtime;
struct tm *tm;
char buf[80];
int take, destroy, team, kill, killp, killa, bomb, conq;
struct distress dist;
take = MTEAM + MTAKE + MVALID;
destroy = MTEAM + MDEST + MVALID;
kill = MALL + MKILL + MVALID;
killp = MALL + MKILLP + MVALID;
killa = MALL + MKILLA + MVALID;
bomb = MTEAM + MBOMB + MVALID;
team = MTEAM + MVALID;
conq = MALL + MCONQ + MVALID;
time(&curtime);
tm = localtime(&curtime);
sprintf(timebuf, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec);
len = strlen(message);
if (from == 255)
{
/* From God */
color = textColor;
}
else
{
color = playerColor(&(players[from]));
}
if (censorMessages)
if ((flags != kill) && (flags != killp) &&
(flags != killa) && (flags != bomb) &&
(flags != take) && (flags != destroy))
censor(message);
/* aha! A new type distress/macro call came in. parse it appropriately */
if (flags == (MTEAM | MDISTR | MVALID))
{
HandleGenDistr(message, from, to, &dist);
len = makedistress(&dist, message, distmacro[dist.distype].macro);
#ifdef BEEPLITE
if (UseLite)
rcdlite(&dist);
#endif
if (len <= 0)
return;
flags ^= MDISTR;
}
if (niftyNewMessages)
{
if (logmess)
{
if (logFile != NULL)
{
fprintf(logFile, "%s: %s\n", timebuf, message);
fflush(logFile);
}
else
{
printf("%s: %s\n", timebuf, message);
}
}
if (!(logmess && logFile == NULL) && flags == conq)
{
/* output conquer stuff to stdout in addition to message window */
fprintf(stdout, "%s\n", message);
if (instr(message, "kill"))
{
fprintf(stdout, "NOTE: The server here does not properly set message flags\n");
fprintf(stdout, "You should probably pester the server god to update....\n");
}
}
if (flags == (MCONFIG + MINDIV + MVALID))
{
if (from == 255)
CheckFeatures(message);
return;
}
if ((flags == team) || (flags == take) || (flags == destroy))
{
W_WriteText(messwt, 0, 0, color, message, len, shipFont(me));
if ((flags == team) &&
!strncmp(message + 10, " ", 5) && (message[15] == 0))
{
printf("dmessage:flags==team PIG call from=%d\n", from);
pmessage(cowid, from, MINDIV);
}
}
else if ((flags == kill) || (flags == killp) ||
(flags == killa) || (flags == bomb))
{
W_WriteText(messwk, 0, 0, color, message, len, 0);
if (!reportKills)
return; /* HW */
}
else if (flags & MINDIV)
{
W_WriteText(messwi, 0, 0, color, message, len, 0);
if (!strncmp(message + 10, " ", 5) && (message[15] == 0))
{
printf("dmessage:MINDIV PIG call from=%d\n", from);
pmessage(cowid, from, MINDIV);
}
}
else
{ /* if we don't know where *
* * the message beLONGs by
* * * this time, stick it
* in * * the all board... */
W_WriteText(messwa, 0, 0, color, message, len, 0);
if (!strncmp(message + 10, " ", 5) && (message[15] == 0))
{
pmessage(cowid, from, MINDIV);
}
}
W_WriteText(reviewWin, 0, 0, color, message, len, 0);
}
else
{
/* ok, here we have the old kludge nastiness that we can turn on if we
* * * HAVE to. yuk, blech, ptooie... */
if ((strncmp(message, "GOD->ALL", 8) == 0 &&
(instr(message, "was kill") ||
instr(message, "killed by"))) ||
(*message != ' ' && instr(message, "We are being attacked")))
{
W_WriteText(messwk, 0, 0, color, message, len, 0);
if (!reportKills)
return;
W_WriteText(reviewWin, 0, 0, color, message, len, 0);
if (logmess)
{
if (logFile != NULL)
{
fprintf(logFile, "%s ", timebuf);
fprintf(logFile, "%s\n", message);
fflush(logFile);
}
else
{
printf("%s ", message);
printf("%s\n", timebuf);
}
}
return;
}
switch (flags & (MTEAM | MINDIV | MALL))
{
case MTEAM:
W_WriteText(messwt, 0, 0, color, message, len, 0);
if (!strncmp(message + 10, " ", 5) && (message[15] == 0))
{
pmessage(cowid, from, MINDIV);
}
if (logmess)
{
if (logFile != NULL)
{
fprintf(logFile, "%s ", timebuf);
fprintf(logFile, "%s\n", message);
fflush(logFile);
}
else
{
printf("%s ", message);
printf("%s\n", timebuf);
}
}
break;
case MINDIV:
if (!(flags & MCONFIG))
W_WriteText(messwi, 0, 0, color, message, len, 0);
if (!strncmp(message + 10, " ", 5) && (message[15] == 0))
{
pmessage(cowid, from, MINDIV);
}
if (logmess)
{
if (logFile != NULL)
{
fprintf(logFile, "%s ", timebuf);
fprintf(logFile, "%s\n", message);
fflush(logFile);
}
else
{
printf("%s ", message);
printf("%s\n", timebuf);
}
}
break;
default:
W_WriteText(messwa, 0, 0, color, message, len, 0);
if (!strncmp(message + 10, " ", 5) && (message[15] == 0))
{
pmessage(cowid, from, MINDIV);
}
if (logmess)
{
if (logFile != NULL)
{
fprintf(logFile, "%s ", timebuf);
fprintf(logFile, "%s\n", message);
fflush(logFile);
}
else
{
printf("%s", message);
printf("%s\n", timebuf);
}
}
break;
}
W_WriteText(reviewWin, 0, 0, color, message, len, 0);
}
}
bool CmdLine::store( const std::vector<std::string>& argv,
boost::program_options::options_description& visible,
boost::program_options::options_description& hidden,
boost::program_options::positional_options_description& positional,
boost::program_options::variables_map ¶ms ) {
if (argv.empty())
return false;
{
// setup binary name
cmdLine.binaryName = argv[0];
size_t i = cmdLine.binaryName.rfind( '/' );
if ( i != string::npos )
cmdLine.binaryName = cmdLine.binaryName.substr( i + 1 );
// setup cwd
char buffer[1024];
#ifdef _WIN32
verify( _getcwd( buffer , 1000 ) );
#else
verify( getcwd( buffer , 1000 ) );
#endif
cmdLine.cwd = buffer;
}
/* don't allow guessing - creates ambiguities when some options are
* prefixes of others. allow long disguises and don't allow guessing
* to get away with our vvvvvvv trick. */
int style = (((po::command_line_style::unix_style ^
po::command_line_style::allow_guessing) |
po::command_line_style::allow_long_disguise) ^
po::command_line_style::allow_sticky);
try {
po::options_description all;
all.add( visible );
all.add( hidden );
po::store( po::command_line_parser(std::vector<std::string>(argv.begin() + 1,
argv.end()))
.options( all )
.positional( positional )
.style( style )
.run(),
params );
if ( params.count("config") ) {
ifstream f( params["config"].as<string>().c_str() );
if ( ! f.is_open() ) {
cout << "ERROR: could not read from config file" << endl << endl;
cout << visible << endl;
return false;
}
stringstream ss;
CmdLine::parseConfigFile( f, ss );
po::store( po::parse_config_file( ss , all ) , params );
f.close();
}
po::notify(params);
}
catch (po::error &e) {
cout << "error command line: " << e.what() << endl;
cout << "use --help for help" << endl;
//cout << visible << endl;
return false;
}
{
BSONArrayBuilder b;
std::vector<std::string> censoredArgv = argv;
censor(&censoredArgv);
for (size_t i=0; i < censoredArgv.size(); i++) {
b << censoredArgv[i];
}
argvArray = b.arr();
}
{
BSONObjBuilder b;
for (po::variables_map::const_iterator it(params.begin()), end(params.end()); it != end; it++){
if (!it->second.defaulted()){
const string& key = it->first;
const po::variable_value& value = it->second;
const type_info& type = value.value().type();
if (type == typeid(string)){
if (value.as<string>().empty())
b.appendBool(key, true); // boost po uses empty string for flags like --quiet
else {
if ( _isPasswordArgument(key.c_str()) ) {
b.append( key, "<password>" );
}
else {
b.append( key, value.as<string>() );
}
}
}
else if (type == typeid(int))
b.append(key, value.as<int>());
else if (type == typeid(double))
b.append(key, value.as<double>());
else if (type == typeid(bool))
b.appendBool(key, value.as<bool>());
else if (type == typeid(long))
b.appendNumber(key, (long long)value.as<long>());
else if (type == typeid(unsigned))
b.appendNumber(key, (long long)value.as<unsigned>());
else if (type == typeid(unsigned long long))
b.appendNumber(key, (long long)value.as<unsigned long long>());
else if (type == typeid(vector<string>))
b.append(key, value.as<vector<string> >());
else
b.append(key, "UNKNOWN TYPE: " + demangleName(type));
}
}
parsedOpts = b.obj();
}
if (params.count("verbose")) {
logLevel = 1;
}
for (string s = "vv"; s.length() <= 12; s.append("v")) {
if (params.count(s)) {
logLevel = s.length();
}
}
if (params.count("quiet")) {
cmdLine.quiet = true;
}
if (params.count("traceExceptions")) {
DBException::traceExceptions = true;
}
if (params.count("maxConns")) {
cmdLine.maxConns = params["maxConns"].as<int>();
if ( cmdLine.maxConns < 5 ) {
out() << "maxConns has to be at least 5" << endl;
return false;
}
else if ( cmdLine.maxConns > MAX_MAX_CONN ) {
out() << "maxConns can't be greater than " << MAX_MAX_CONN << endl;
return false;
}
}
if (params.count("objcheck")) {
cmdLine.objcheck = true;
}
if (params.count("noobjcheck")) {
if (params.count("objcheck")) {
out() << "can't have both --objcheck and --noobjcheck" << endl;
return false;
}
cmdLine.objcheck = false;
}
if (params.count("bind_ip")) {
// passing in wildcard is the same as default behavior; remove and warn
if ( cmdLine.bind_ip == "0.0.0.0" ) {
cout << "warning: bind_ip of 0.0.0.0 is unnecessary; listens on all ips by default" << endl;
cmdLine.bind_ip = "";
}
}
#ifndef _WIN32
if (params.count("unixSocketPrefix")) {
cmdLine.socket = params["unixSocketPrefix"].as<string>();
}
if (params.count("nounixsocket")) {
cmdLine.noUnixSocket = true;
}
if (params.count("fork") && !params.count("shutdown")) {
cmdLine.doFork = true;
}
#endif // _WIN32
if (params.count("logpath")) {
cmdLine.logpath = params["logpath"].as<string>();
if (cmdLine.logpath.empty()) {
cout << "logpath cannot be empty if supplied" << endl;
return false;
}
}
cmdLine.logWithSyslog = params.count("syslog");
cmdLine.logAppend = params.count("logappend");
if (!cmdLine.logpath.empty() && cmdLine.logWithSyslog) {
cout << "Cant use both a logpath and syslog " << endl;
return false;
}
if (cmdLine.doFork && cmdLine.logpath.empty() && !cmdLine.logWithSyslog) {
cout << "--fork has to be used with --logpath or --syslog" << endl;
return false;
}
if (params.count("keyFile")) {
cmdLine.keyFile = params["keyFile"].as<string>();
}
if ( params.count("pidfilepath")) {
cmdLine.pidFile = params["pidfilepath"].as<string>();
}
if (params.count("setParameter")) {
std::vector<std::string> parameters =
params["setParameter"].as<std::vector<std::string> >();
for (size_t i = 0, length = parameters.size(); i < length; ++i) {
std::string name;
std::string value;
if (!mongoutils::str::splitOn(parameters[i], '=', name, value)) {
cout << "Illegal option assignment: \"" << parameters[i] << "\"" << endl;
return false;
}
ServerParameter* parameter = mapFindWithDefault(
ServerParameterSet::getGlobal()->getMap(),
name,
static_cast<ServerParameter*>(NULL));
if (NULL == parameter) {
cout << "Illegal --option parameter: \"" << name << "\"" << endl;
return false;
}
Status status = parameter->setFromString(value);
if (!status.isOK()) {
cout << "Bad value for parameter \"" << name << "\": " << status.reason()
<< endl;
return false;
}
}
}
#ifdef MONGO_SSL
if (params.count("sslWeakCertificateValidation")) {
cmdLine.sslWeakCertificateValidation = true;
}
if (params.count("sslOnNormalPorts")) {
cmdLine.sslOnNormalPorts = true;
if ( cmdLine.sslPEMKeyFile.size() == 0 ) {
log() << "need sslPEMKeyFile" << endl;
return false;
}
if (cmdLine.sslWeakCertificateValidation &&
cmdLine.sslCAFile.empty()) {
log() << "need sslCAFile with sslWeakCertificateValidation" << endl;
return false;
}
}
else if (cmdLine.sslPEMKeyFile.size() ||
cmdLine.sslPEMKeyPassword.size() ||
cmdLine.sslCAFile.size() ||
cmdLine.sslCRLFile.size() ||
cmdLine.sslWeakCertificateValidation) {
log() << "need to enable sslOnNormalPorts" << endl;
return false;
}
#endif
return true;
}
int main() {
//convert();
censor();
return 0; // Lets the operating system know everything ran successfully.
}