//! \brief
void IncomingUdp::onExecute()
{
char buffer[ max_packet_size ]; // TODO: Member variable? Allow max_packet_size to be defined by configuration
// Memory allocation comes from round-robin memory buffer(s) to remove
// the necessity for new/delete blocks
while ( isActive() )
{
const int dataLength = m_socket.recv( buffer, max_packet_size );
if ( dataLength < 0 )
{
if ( isActive() )
{
processSocketError( dataLength );
}
}
else if ( dataLength > 0 ) // TODO: Simpler if the message queue handles this?
{
m_queue->push( buffer, dataLength );
// TODO: Should validate packet then pass it into message queue, we shouldn't know about UserInfo at this level.
// TODO: Decrypt packet content
UserInfo *user = findUser( packetInfo.publicKey );
if ( user && user->ipAddress == packetInfo.ipAddress )
{
user->queueMessage( buffer, dataLength );
}
else
{
m_log->Error( kModuleName, "Received unexpected UDP packet.\n" );
}
}
}
}
NetworkServer::AutoPacket NetworkServer::receive()
{
assert(isConnected());
for (;;) {
if (_queuedUser) {
removeUser(_queuedUser);
_queuedUser = 0;
}
Packet* raw = _peer->Receive();
if (!raw) {
return AutoPacket();
}
AutoDepacketer depacketer(*_peer, raw);
AutoPacket packet(processPacket(*raw));
if (packet.get()) {
User *user = findUser(raw->systemAddress);
if (!user) {
packetHeader(std::cout, *raw);
std::cout << "Packet from unknown user: " << int(packet->kind()) << std::endl;
continue;
}
packet->read(raw, user);
return packet;
}
}
}
// add USER
int CFtpd::addUser(char *login_, char *passwd_, int simConn_, int timeOut_) {
CUser *u;
int i;
// It's forbidden to create blank logins
if (lstrcmp(login_, "") == 0) return -1;
/*
if (rootDir_[strlen(rootDir_)-1]!='\\') {
strcat(rootDir_, "\\\0");
}
*/
i = findUser(login_);
if (i>=0) {
// edit user
// m_Users[i]->set(login_, passwd_, simConn_, timeOut_);
}
else {
// add User
u = (CUser*)new CUser();
u->set(login_, passwd_, simConn_, timeOut_);
m_Users[nbUsers] = u;
i = nbUsers;
nbUsers++;
}
return i;
}
void handle_WHOIS(char** params, int socket)
{
char msgbuf[512];
char *nick = params[1];
char user[500];
char realname[500];
struct ClientData * vip = findUser(nick,&clientList); //the VIP who everyone wants to know about, for whom they keep walking around town asking WHOIS in all caps and demanding a reply
struct ClientData * looker = (struct ClientData *)list_seek(&clientList, &socket);
char lookernick[10];
strcpy(lookernick, looker->nick);
//check if the nick exists
if(vip == NULL){
sprintf(msgbuf, ":%s 401 %s %s :No such nick/channel\r\n", host, lookernick, nick);
sendMessage(msgbuf, socket);
return;
}
strcpy(user, vip->user);
strcpy(realname, vip->real);
//send the info
sprintf(msgbuf, ":%s 311 %s %s %s %s * :%s\r\n", host, lookernick, nick, user, host, realname);
sendMessage(msgbuf, socket);
sprintf(msgbuf, ":%s 312 %s %s %s :The best server ever\r\n", host, lookernick, nick, host);
sendMessage(msgbuf, socket);
sprintf(msgbuf, ":%s 318 %s %s :End of WHOIS list\r\n", host, lookernick, nick);
sendMessage(msgbuf, socket);
return;
}
const QString EvaSetting::getProxyUsername(const int id)
{
int index = findUser(id);
if(index!=-1){
return userList.at(index)->proxyUserName;
}
return "";
}
bool
ObjectCache::findUser(Id user_id, User& user)
{
User* object = findUser(user_id);
if (object == NULL) return false;
user = *object;
return true;
}
const QCString EvaSetting::getProxyParam(const int id)
{
int index = findUser(id);
if(index!=-1){
return userList.at(index)->base64param.stripWhiteSpace();
}
return "";
}
const short EvaSetting::getPort(const int id)
{
int index = findUser(id);
if(index!=-1){
return userList.at(index)->port;
}
return 0;
}
const int EvaSetting::getServer(const int id)
{
int index = findUser(id);
if(index!=-1){
return userList.at(index)->proxy;
}
return 0;
}
const char *EvaSetting::getPassword(const int id)
{
int index = findUser(id);
if(index!=-1){
return (char*)(userList.at(index)->md5Pwd);
}
return "";
}
const bool EvaSetting::isHiddenChecked(const int id)
{
int index = findUser(id);
if(index!=-1){
return (userList.at(index)->flag & 0x02);
}
return false;
}
// better user update. Take slots out of the picture altogether. Find empty slot and add
// or if tag is there, change mask
// or report: no empty slots, sorry charlie
boolean EEPROM_UserDB::upsertUser(byte userMask, unsigned long tagNumber) {
int offset;// = EEPROM_FIRSTUSER;
byte EEPROM_buffer[5] ={0,0,0,0,0};
boolean foundEmpty = false;
byte byteVal = 0;
if (tagNumber > 0xffffffff || tagNumber < 0) {
Serial.println("Tag Number must be between 0 and 0xFFFFFFFF. Ignored.");
return false;
}
offset = findUser(tagNumber);
if (offset >= 0) {
Serial.print("Tag: ");
Serial.print(tagNumber,HEX);
EEPROM.write(offset+4, userMask);
Serial.print(" found and updated to mask:");
Serial.println(userMask,DEC);
return true;
}
// TODO, prob in following section
// right place to start searching
offset = EEPROM_FIRSTUSER;
while (!foundEmpty & (offset < EEPROM_LASTUSER)) {
for (int i = 0; i < 5; i++) {
if (EEPROM.read(offset + i) == 0xFF) {
byteVal++;
}
}
if (byteVal == 5) {
foundEmpty = true;
} else {
offset += 5;
byteVal = 0; // reset
}
}
if (offset < EEPROM_LASTUSER) {
EEPROM_buffer[0] = byte(tagNumber & 0xFFF); // Fill the buffer with the values to write to bytes 0..4
EEPROM_buffer[1] = byte(tagNumber >> 8);
EEPROM_buffer[2] = byte(tagNumber >> 16);
EEPROM_buffer[3] = byte(tagNumber >> 24);
EEPROM_buffer[4] = byte(userMask);
for(int i=0; i<5; i++){
EEPROM.write((offset+i), (EEPROM_buffer[i])); // Store the resulting value in 5 bytes of EEPROM.
}
Serial.print("Tag: ");
Serial.print(tagNumber,HEX);
Serial.print(" successfully added with mask:");
Serial.println(userMask,DEC);
} else {
/*Function to handle a NICK message to our client by updating the user struct associated with the socket # it's coming from to have the right nickname */
void handle_NICK(char** params, int socket)
{
char msgbuf[512];
char *nick;
char *user;
//read the nick we got in the command
nick = params[1];
//check if the nick is already taken
struct ClientData * ifused = findUser(nick,&clientList);
if(ifused != NULL){
printf("nick was taken\n");
sprintf(msgbuf, ":%s 433 * %s :Nickname is already in use\r\n", host, nick);
sendMessage(msgbuf, socket);
return;
}
//look in the list of users for the matching socket number
pthread_mutex_lock(&listLock);
struct ClientData * ourCli = (struct ClientData *)list_seek(&clientList, &socket);
if(ourCli == NULL) {
printf("Failing on list seek.\n");
}
//add in their nick
strcpy(ourCli->nick, nick);
user = ourCli->user;
pthread_mutex_unlock(&listLock);
//list_dump_file(&clientList, "oneuserlist.txt", NULL);
//logging!
printf("Client # %d now has nickname %s.\n", ourCli->ourSocket, nick);
printf("Client # %d also has username %s.\n", ourCli->ourSocket, user);
//check if they have registered both a nick and a user
if(nick[0] != '\0' && user[0] != '\0'){
ourCli->registered = 1; //yay
sprintf(msgbuf,":%s 001 %s :Welcome to the Internet Relay Network %s!%[email protected]\r\n", host, nick, nick, user);
//welcome them
sendMessage(msgbuf, ourCli->ourSocket);
sprintf(msgbuf, ":%s 002 %s :Your host is %s, running version chirc-0.1\r\n", host, nick, host);
sendMessage(msgbuf, ourCli->ourSocket);
sprintf(msgbuf, ":%s 003 %s :This server was created 2012-01-02 13:30:04\r\n", host, nick);
sendMessage(msgbuf, ourCli->ourSocket);
sprintf(msgbuf, ":%s 004 %s %s chirc-0.1 ao mtov\r\n", host, nick, host);
sendMessage(msgbuf, ourCli->ourSocket);
handle_LUSERS(NULL, socket);
handle_MOTD(NULL, socket);
}
return;
}
void handle_NOTICE(char** params, int socket)
{
char msgbuf[512];
int destsocket;
channel *chan;
struct ClientData *srcUser;
//get the destination and message from the command
char *dest = params[1];
char *msg = params[10];
srcUser = (struct ClientData *)list_seek(&clientList, &socket);
if(dest[0] == '#'){//channel
chan = (channel *) findChannel(dest);
if(chan == NULL){
//sprintf(msgbuf, ":%s 401 %s %s :No such nick/channel\r\n", host, srcUser->nick, dest);
//sendMessage(msgbuf, socket);
return;
}
//check if the user is in the channel
if(isUserInChannel(socket, chan) == -1){
//sprintf(msgbuf, ":%s 404 %s %s :Cannot send to channel\r\n", host, srcUser->user, dest);
//sendMessage(msgbuf, socket);
return;
}
sprintf(msgbuf, ":%s!%s@hostname NOTICE %s :%s\r\n", srcUser->nick, srcUser->user, dest, msg);
printf("message was: %s\n", msgbuf);
messageAllUsers(msgbuf, chan, socket);
} else { //user
//find the information of the destination
struct ClientData * destUser = findUser(dest, &clientList);
if(destUser == NULL){
return;
}
destsocket = destUser->ourSocket;
//find the nick of the source
struct ClientData *srcUser = (struct ClientData *)list_seek(&clientList, &socket);
//send the message
sprintf(msgbuf, ":%s!%s@sentuser NOTICE %s :%s\r\n", srcUser->nick, srcUser->user, dest, msg);
sendMessage(msgbuf, destsocket);
return;
}
}
UserData* UserController :: checkIn(std::string ID, std::string passwd)
{
Logging log("UserController :: checkIn",true);
UserData* toReturn = findUser(ID);
if(toReturn)
{
if(toReturn->Password() == passwd)
return toReturn;
else
throw PasswordNotCorrectException((std::string)"password wrong!");
}
else throw ItemNotFoundException((std::string)"user not exist!");
}
Wt::Auth::IssuedToken OidcUserDatabase::idpTokenAdd(const std::string& value,
const Wt::WDateTime& expirationTime,
const std::string& purpose,
const std::string& scope,
const std::string& redirectUri,
const Wt::Auth::User& user,
const Wt::Auth::OAuthClient& authClient)
{
WithUser findUser(*this, user);
WithOAuthClient findOAuthClient(*this, authClient);
IssuedToken *token = new IssuedToken(value, expirationTime, purpose, scope, redirectUri, user_->user(), authClient_);
issuedToken_ = session_.add(token);
return Wt::Auth::IssuedToken(boost::lexical_cast<std::string>(issuedToken_.id()), *this);
}
static PSPAMResult_t handleOpenRequest(char *msgBuf)
{
char user[USERNAME_LEN], rhost[HOSTNAME_LEN];
pid_t pid, sid;
struct passwd *spasswd;
User_t *pamUser;
PSPAMResult_t res = PSPAM_RES_DENY;
char *ptr = msgBuf;
/* ensure we use the same byteorder as the PAM module */
bool byteOrder = setByteOrder(true);
/* get ssh pid */
getPid(&ptr, &pid);
/* get ssh sid */
getPid(&ptr, &sid);
/* get pam username */
getString(&ptr, user, sizeof(user));
/* get pam rhost */
getString(&ptr, rhost, sizeof(rhost));
/* reset psserial's byteorder */
setByteOrder(byteOrder);
mdbg(PSPAM_LOG_DEBUG, "%s: got pam request user: '******' pid: %i sid: %i"
" rhost: '%s'\n", __func__, user, pid, sid, rhost);
errno = 0;
spasswd = getpwnam(user);
if (!spasswd && errno) mwarn(errno, "%s: getpwnam(%s)", __func__, user);
pamUser = findUser(user, NULL);
/* Determine user's allowance */
if (spasswd && isPSAdminUser(spasswd->pw_uid, spasswd->pw_gid)) {
res = PSPAM_RES_ADMIN_USER;
} else if (pamUser) {
if (pamUser->state == PSPAM_STATE_PROLOGUE) {
res = PSPAM_RES_PROLOG;
} else {
res = PSPAM_RES_BATCH;
addSession(user, rhost, pid, sid);
}
}
mdbg(PSPAM_LOG_DEBUG, "%s: reply to user '%s' rhost '%s': %i\n", __func__,
user, rhost, res);
return res;
}
void find(char* input) {
if (begins(input, "snack ")) {
debug("exec find snack cmd");
findSnack(input + 6);
} else if (begins(input, "user ")) {
debug("exec find user cmd");
findUser(input + 5);
} else {
debug("no match found in find");
debug("try snack");
findSnack(input);
}
}
const int EvaSetting::getConnectType(const int id) // 0: udp, 1: tcp, 2: http proxy
{
int index = findUser(id);
int type = 0;
if(index!=-1){
Q_UINT8 flag = userList.at(index)->flag;
if(flag & 0x10)
type = 0;
else if(flag & 0x08)
type = 1;
else if(flag & 0x04)
type = 2;
}
return type;
}
/*!
\details An user as changed a nick
\param s is the string from Irc server
*/
void IrcChannel::userNickChange(QString s)
{
// :[email protected] NICK :dddtre
QRegExp r (":([^!]+).*\\sNICK\\s:(.*)");
if(r.exactMatch(s))
{
QStringList l = r.capturedTexts();
QListWidgetItem *it = findUser(l.at(1));
if(it)
{
it->setText( hasPrivilege(it->text()) + l.at(2));
mTextEdit->appendHtml("<font color=\"#ff0000\">User " + l.at(1) + " is now know as " + l.at(2) + "</font>");
}
}
}
bool ListUsers::DeleteUser(string l)
{
User* victim = findUser(l);
if (victim != NULL)
{
if (victim->next != NULL) victim->next->previous = victim->previous;
if (victim->previous != NULL) victim->previous->next = victim->next;
delete victim;
return 1;
}
else
{
return 0;
}
}
/*!
\details An user quit Irc server
\param l is the string from Irc server
*/
void IrcChannel::userQuit(QString l)
{
//:ThomasGHenry!n=tghenry@nat/ibm/x-e360141219a099ca QUIT :"Leaving."
QRegExp r (":([^!]+).*\\sQUIT\\s:(.*)");
if(r.exactMatch(l))
{
QStringList t = r.capturedTexts();
QListWidgetItem *it = findUser(t.at(1));
if( it )
{
mMemberList->removeItemWidget( it );
delete it;
mTextEdit->appendHtml("<font color=\"#0000ff\">* " + t.at(1) + " has quit " + name() + " " + t.at(2) + "</font>");
}
}
}
bool ListUsers::AddUser(string l, string p, int a)
{
if (findUser(l) == NULL) {
User* tempLast = last;
last = new User(l, p, a, tempLast);
if (tempLast == NULL)
{
first = last;
}
else
{
last->previous = tempLast;
tempLast->next = last;
}
return 1;
}
else return 0;
}
/*!
\details An user quit this channel
\param l is the string from Irc server
*/
void IrcChannel::userPart(QString l)
{
// :[email protected] PART #testmonkeystudio :quit message
QRegExp r (":([^!]+).*\\sPART\\s([^ ]+)\\s:(.*)");
if(r.exactMatch(l))
{
QStringList t = r.capturedTexts();
if(t.at(2).toLower() == name())
{
QListWidgetItem *it = findUser(t.at(1));
if( it )
{
mMemberList->removeItemWidget( it );
delete it;
mTextEdit->appendHtml("<font color=\"#0000ff\">* " + t.at(1) + " has left " + name() + " " + t.at(3) + "</font>");
}
}
}
}
HintedUser ClientManager::findLegacyUser(const string& nick) const noexcept {
if(nick.empty())
return HintedUser();
Lock l(cs);
for(auto i: clients) {
auto nmdc = dynamic_cast<NmdcHub*>(i);
if(nmdc) {
/** @todo run the search directly on non-UTF-8 nicks when we store them. */
auto ou = nmdc->findUser(nmdc->toUtf8(nick));
if(ou) {
return HintedUser(*ou);
}
}
}
return HintedUser();
}
void serverMessage(std::string command, std::string option, std::string data, IClientSocket *socket)
{
// Server command: client attempts a connection
if(command == "newClient"){
std::string idcode = idstring(socket);
if(findUser(data) == true){
remoteMessage("/error,userFound",socket);
}else{
// Inform the client connection is accepted on server
remoteMessage("/accepted,"+idcode,socket);
// Inform all clients to show user as connected
broadcastMessage("/userConnect,"+data+":"+idcode, socket);
// Now send a list of current users to the client you just accepted
std::string token,userlist = getUserlist();
for(size_t pos = userlist.find(";");pos != std::string::npos;pos = userlist.find(";")){
token = userlist.substr(0,pos);
userlist = userlist.substr(pos+1);
size_t sep = token.find(",");
std::string user = token.substr(0,sep);
std::string id = token.substr(sep+1);
remoteMessage("/userConnect,"+user+":"+id,socket);
}
}
}
if(command == "info")
{
if(data == "listening") data = "Listening for clients";
if(data == "serverStart") data = "Server started";
if(data == "serverStop") data = "Server stopped, all clients disconnected";
if(data == "newClient") data = "incoming connection from client";
insertMessage("info",data);
}
}
void IRCSession::processCommandQuit(shared_ptr<IRCCommandQuit> command)
{
OS_ASSERT(command != nullptr);
shared_ptr<IRCUser> user = findUser(command->getNick());
if(user == nullptr)
{
OS_ASSERTFALSE();
return;
}
{
OS_LOCK(m_dataCS);
for(Rooms::const_iterator i = m_rooms.begin(); i != m_rooms.end(); ++i)
{
i->second->removeUser(user);
}
}
updateAllRooms(false);
}
std::pair<std::string,std::string> UserController :: getDefaultUser()
{
Logging log("UserController :: getDefaultUser",true);
std::ifstream input(__defaultUserFile);
std::string ID,passwd;
int rem;
if(input)
{
input >> ID >> rem;
UserData* defaultUser = findUser(ID);
if(defaultUser)
{
log << "INFO now default user " << defaultUser->Name() << std::endl;
if(rem)
{
log << "INFO remember password." << std::endl;
passwd = defaultUser->Password();
}
}
else ID="";
}
return std::make_pair(ID,passwd);
}
/*!
\details Modify the current privilege for one user in this channel.
\param s is the string from Irc server
*/
void IrcChannel::setUserPrivilege(QString s)
{
// :[email protected] MODE #testmonkeystudio +o xiantia
// * after sets mode: +o xiantia
QRegExp r (":([^!]+).*\\sMODE\\s([^ ]+)\\s([^ ]+)\\s([^ ]+).*");
if(r.exactMatch(s))
{
QStringList t = r.capturedTexts();
if(t.at(2).toLower() == name())
{
QListWidgetItem *it = findUser(t.at(4));
if(it)
{
mTextEdit->appendHtml("<font color=\"#00ff00\">* " + t.at(1) + " sets mode : " + t.at(3) + " " + t.at(4) + "</font>");
QString n = userPrefix.value(t.at(3)); // get the corresponding tag og privilege
QString u = it->text();
if(hasPrivilege(u).isEmpty()) // user haven't privilege, add this
it->setText( n + u);
else
it->setText( u.replace(0,1, n) ); // user have privilege, modify this
}
}
}
}
DataObject*
ObjectCache::find(Id object_id, bool cacheOnly)
{
if (object_id == INVALID_ID)
return NULL;
if (_objects.find(object_id) != _objects.end())
return _objects[object_id];
if (cacheOnly)
return NULL;
DataObject object;
if (!_db->lookup(object_id, object))
return NULL;
switch (object.dataType()) {
case DataObject::ACCOUNT: return findAccount(object_id);
case DataObject::ADJUST_REASON: return findAdjustReason(object_id);
case DataObject::CARD_ADJUST: return findCardAdjust(object_id);
case DataObject::CHARGE: return findCharge(object_id);
case DataObject::CHEQUE: return findCheque(object_id);
case DataObject::CLAIM: return findReceive(object_id);
case DataObject::COMPANY: return findCompany(object_id);
case DataObject::COUNT: return findCount(object_id);
case DataObject::CUSTOMER: return findCustomer(object_id);
case DataObject::CUST_TYPE: return findCustomerType(object_id);
case DataObject::DEPT: return findDept(object_id);
case DataObject::DISCOUNT: return findDiscount(object_id);
case DataObject::EMPLOYEE: return findEmployee(object_id);
case DataObject::EXPENSE: return findExpense(object_id);
case DataObject::EXTRA: return findExtra(object_id);
case DataObject::GENERAL: return findGeneral(object_id);
case DataObject::GROUP: return findGroup(object_id);
case DataObject::INVOICE: return findInvoice(object_id);
case DataObject::ITEM: return findItem(object_id);
case DataObject::ITEM_ADJUST: return findItemAdjust(object_id);
case DataObject::ITEM_PRICE: return findItemPrice(object_id);
case DataObject::LABEL_BATCH: return findLabelBatch(object_id);
case DataObject::LOCATION: return findLocation(object_id);
case DataObject::NOSALE: return findNosale(object_id);
case DataObject::ORDER: return findOrder(object_id);
case DataObject::PO_TEMPLATE: return findOrderTemplate(object_id);
case DataObject::PAT_GROUP: return findPatGroup(object_id);
case DataObject::PAT_WS: return findPatWorksheet(object_id);
case DataObject::PAYOUT: return findPayout(object_id);
case DataObject::PERSONAL: return findPersonal(object_id);
case DataObject::PLU: assert("Invalid data type: PLU");
case DataObject::PRICE_BATCH: return findPriceBatch(object_id);
case DataObject::PROMO_BATCH: return findPromoBatch(object_id);
case DataObject::QUOTE: return findQuote(object_id);
case DataObject::RECEIPT: return findReceipt(object_id);
case DataObject::RECEIVE: return findReceive(object_id);
case DataObject::RECONCILE: return findReconcile(object_id);
case DataObject::RECURRING: return findRecurring(object_id);
case DataObject::REPORT: assert("Invalid data type: REPORT");
case DataObject::RETURN: return findInvoice(object_id);
case DataObject::SECURITY_TYPE: return findSecurityType(object_id);
case DataObject::SHIFT: return findShift(object_id);
case DataObject::SLIP: return findSlip(object_id);
case DataObject::STATION: return findStation(object_id);
case DataObject::STORE: return findStore(object_id);
case DataObject::SUBDEPT: return findSubdept(object_id);
case DataObject::TAX: return findTax(object_id);
case DataObject::TENDER: return findTender(object_id);
case DataObject::TEND_COUNT: return findTenderCount(object_id);
case DataObject::TEND_ADJUST: return findTenderAdjust(object_id);
case DataObject::TERM: return findTerm(object_id);
case DataObject::TODO: return findTodo(object_id);
case DataObject::USER: return findUser(object_id);
case DataObject::VENDOR: return findVendor(object_id);
case DataObject::WITHDRAW: return findWithdraw(object_id);
}
qWarning("Unknown object type: " + object.dataTypeName());
return NULL;
}
