int serverGetLatestEventData(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
lua_pushstring(L, (const char*)server->GetLatestEventData());
return 1;
}
int serverGetLatestEventAddress(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
lua_pushstring(L, server->GetLatestEventAddress().c_str());
return 1;
}
int serverGetClientAddressByIndex(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
lua_pushstring(L, server->GetClientAddressByIndex(luaL_checknumber(L, 2)).c_str());
return 1;
}
//==============================================================================
bool MinosClientConnection::checkFrom( TiXmlElement *tix )
{
if ( !fromIdSet )
{
return true;
}
// if no "from" insert one
const char *sfrom = tix->Attribute( "from" );
if ( !sfrom )
{
// insert a from of ourselves
std::string from = makeJid();
if ( from.size() )
{
tix->SetAttribute( "from", from.c_str() );
}
}
else
{
MinosId from( sfrom );
if ( !checkServer( from ) )
return false;
if ( !checkUser( from ) )
return false;
}
return true;
}
int serverClearLatestEvent(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
server->ClearLatestEvent();
return 0;
}
static san_sServer* addServer(
pwr_tStatus* sts, gdb_sNode* np, gdb_sObject* op, net_sSanEntry* ep)
{
san_sServer* sp;
sp = hash_Search(NULL, gdbroot->sans_ht, &ep->sid);
if (sp != NULL)
return sp;
sp = pool_Alloc(sts, gdbroot->pool, sizeof(san_sServer));
if (sp == NULL)
return NULL;
sp->sane = *ep;
sp = hash_Insert(sts, gdbroot->sans_ht, sp);
if (sp == NULL)
return NULL;
/* To do !!!! This is a pool leak !!!!!! */
if (gdbroot->is_tmon)
sp->op = op;
pool_QinsertPred(NULL, gdbroot->pool, &sp->sansAct_ll, &np->sansAct_lh);
sp->flags.b.sansAct = 1;
np->sansAct_lc++;
np->sans_gen++;
return checkServer(np, sp);
}
std::int32_t CmdRegisterNym::run(
std::string server,
std::string mynym,
std::string publish,
std::string primary)
{
if (!checkServer("server", server)) { return -1; }
if (!checkNym("mynym", mynym)) { return -1; }
bool shouldPublish{false};
if ("" != publish && !checkBoolean("publish", publish)) {
return -1;
} else {
shouldPublish = publish == "true";
}
if (!checkNym("mynym", mynym)) { return -1; }
bool isPrimary{false};
if ("" != primary && !checkBoolean("primary", primary)) {
return -1;
} else {
isPrimary = primary == "true";
}
if (!shouldPublish && isPrimary) {
otOut << "Can't make the server primary if it isn't published.";
return -1;
}
auto& sync = Opentxs::Client().Sync();
OTIdentifier taskID = sync.RegisterNym(
Identifier::Factory(mynym),
Identifier::Factory(server),
shouldPublish,
isPrimary);
ThreadStatus status = sync.Status(taskID);
while (status == ThreadStatus::RUNNING) {
Log::Sleep(std::chrono::milliseconds(100));
status = sync.Status(taskID);
}
switch (status) {
case ThreadStatus::FINISHED_SUCCESS: {
otOut << "Nym registered successfully " << std::endl;
} break;
case ThreadStatus::FINISHED_FAILED: {
otOut << "Nym not registered " << std::endl;
[[fallthrough]];
}
case ThreadStatus::ERROR:
case ThreadStatus::SHUTDOWN:
default: {
return -1;
}
}
return 0;
}
int serverGetNumberOfClients(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
lua_pushnumber(L, server->GetNumberOfClients());
return 1;
}
int serverGetOutLimit(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
lua_pushnumber(L, server->GetOutLimit());
return 1;
}
int serverIsInitialized(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
lua_pushboolean(L, server->IsInitialized());
return 1;
}
int serverGetMaxChannels(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
lua_pushnumber(L, server->GetMaxChannels());
return 1;
}
std::int32_t CmdAcknowledgeBailment::run(
std::string server,
std::string mynym,
std::string hisnym,
std::string mypurse)
{
if (!checkServer("server", server)) { return -1; }
if (!checkNym("mynym", mynym)) { return -1; }
if (!checkNym("hisnym", hisnym)) { return -1; }
std::string terms = inputText("Deposit instructions");
if (0 == terms.size()) { return -1; }
std::string response;
{
response = Opentxs::
Client()
.ServerAction()
.AcknowledgeBailment(
Identifier::Factory(mynym),
Identifier::Factory(server),
Identifier::Factory(hisnym),
Identifier::Factory(mypurse),
terms)
->Run();
}
return processResponse(response, "acknowledge bailment");
}
void sansm_Check()
{
static unsigned int idx = 0;
gdb_sNode* np;
pool_sQlink* nl;
san_sServer* sp;
pool_sQlink* sl;
gdb_AssumeLocked;
if (idx == gdbroot->db->al_idx)
return;
for (nl = pool_Qsucc(NULL, gdbroot->pool, &gdbroot->db->nod_lh);
nl != &gdbroot->db->nod_lh;) {
np = pool_Qitem(nl, gdb_sNode, nod_ll);
nl = pool_Qsucc(NULL, gdbroot->pool, nl);
if (!np->flags.b.connected)
continue;
for (sl = pool_Qsucc(NULL, gdbroot->pool, &np->sansAct_lh);
sl != &np->sansAct_lh;) {
sp = pool_Qitem(sl, san_sServer, sansAct_ll);
sl = pool_Qsucc(NULL, gdbroot->pool, sl);
checkServer(np, sp);
}
}
idx = gdbroot->db->al_idx;
}
int serverInitializeMinimal(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
unsigned short port = (unsigned short)luaL_checknumber(L, 2);
server->Initialize(port);
return 0;
}
int serverGetLatestEvent(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
int eventIndex = server->GetLatestEvent();
lua_pushstring(L, mugg::net::EventString[eventIndex]);
return 1;
}
int serverSetBandwidthLimit(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
unsigned int inLimit = luaL_checknumber(L, 2);
unsigned int outLimit = luaL_checknumber(L, 3);
server->SetBandwidthLimit(inLimit, outLimit);
return 0;
}
int serverInitialize(lua_State* L) {
mugg::net::Server* server = checkServer(L, 1);
const char* address = luaL_checkstring(L, 2);
unsigned short port = (unsigned short)luaL_checknumber(L, 3);
int maxConnections = luaL_checknumber(L, 4);
int maxChannels = luaL_checknumber(L, 5);
int incThrottle = luaL_checknumber(L, 6);
int outThrottle = luaL_checknumber(L, 7);
server->Initialize(address, port, maxConnections, maxChannels, incThrottle, outThrottle);
return 0;
}
void KinectRegistration::spin()
{
ros::Rate lr(50);
if( !checkServer() )
{
return;
}
int req_num_clouds = 360 / angle_rotation_;
while( (num_clouds_ < req_num_clouds ) )
{
ros::spinOnce();
lr.sleep();
}
ROS_INFO("Number of point clouds received: %d", num_clouds_ );
}
void OptionsServerPage::currentServerChanged(const QModelIndex &newIndex, const QModelIndex &oldIndex)
{
DVRServer *server = oldIndex.data(DVRServersModel::DVRServerRole).value<DVRServer *>();
if (server)
{
saveChanges(server);
server->disconnect(this);
m_connectionStatus->setVisible(false);
}
server = newIndex.data(DVRServersModel::DVRServerRole).value<DVRServer *>();
if (!server)
{
m_nameEdit->clear();
m_hostnameEdit->clear();
m_portEdit->clear();
m_usernameEdit->clear();
m_passwordEdit->clear();
m_connectionType->setCurrentIndex(DVRServerConnectionType::RTSP);
return;
}
m_nameEdit->setText(server->configuration().displayName());
m_hostnameEdit->setText(server->configuration().hostname());
m_portEdit->setText(QString::number(server->serverPort()));
m_usernameEdit->setText(server->configuration().username());
m_passwordEdit->setText(server->configuration().password());
m_autoConnect->setChecked(server->configuration().autoConnect());
m_connectionType->setCurrentIndex(server->configuration().connectionType());
connect(server, SIGNAL(loginSuccessful()), SLOT(setLoginSuccessful()));
connect(server, SIGNAL(loginError(QString)), SLOT(setLoginError(QString)));
connect(server, SIGNAL(loginRequestStarted()), SLOT(setLoginConnecting()));
checkServer();
if (server->isOnline())
setLoginSuccessful();
else if (server->isLoginPending())
setLoginConnecting();
else if (!server->errorMessage().isEmpty())
setLoginError(server->errorMessage());
}
OptionsServerPage::OptionsServerPage(DVRServerRepository *serverRepository, QWidget *parent)
: OptionsDialogPage(parent), m_serverRepository(serverRepository)
{
Q_ASSERT(m_serverRepository);
QBoxLayout *mainLayout = new QVBoxLayout(this);
QBoxLayout *topLayout = new QHBoxLayout;
mainLayout->addLayout(topLayout);
/* Servers list */
m_serversView = new QTreeView;
m_model = new DVRServersModel(serverRepository, false, m_serversView);
m_proxyModel = new DVRServersProxyModel(m_model);
m_proxyModel->setDynamicSortFilter(true);
m_proxyModel->setSourceModel(m_model);
m_proxyModel->sort(0);
m_serversView->setModel(m_proxyModel);
m_serversView->header()->setHighlightSections(false);
m_serversView->header()->setResizeMode(QHeaderView::ResizeToContents);
m_serversView->header()->setResizeMode(0, QHeaderView::Stretch);
m_serversView->header()->setStretchLastSection(false);
m_serversView->setEditTriggers(QAbstractItemView::NoEditTriggers);
m_serversView->setMinimumSize(480, 150);
m_serversView->setSelectionBehavior(QAbstractItemView::SelectRows);
m_serversView->setSelectionMode(QAbstractItemView::SingleSelection);
m_serversView->setItemsExpandable(false);
m_serversView->setRootIsDecorated(false);
topLayout->addWidget(m_serversView);
connect(m_serversView->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
SLOT(currentServerChanged(QModelIndex,QModelIndex)));
/* Editing area */
QGridLayout *editsLayout = new QGridLayout;
mainLayout->addLayout(editsLayout);
QLabel *label = new QLabel(tr("Name:"));
editsLayout->addWidget(label, 0, 0, Qt::AlignRight);
m_nameEdit = new QLineEdit;
editsLayout->addWidget(m_nameEdit, 0, 1);
label = new QLabel(tr("Hostname:"));
editsLayout->addWidget(label, 1, 0, Qt::AlignRight);
QBoxLayout *hnLayout = new QBoxLayout(QBoxLayout::LeftToRight);
m_hostnameEdit = new QLineEdit;
hnLayout->addWidget(m_hostnameEdit);
m_portEdit = new QLineEdit;
m_portEdit->setValidator(new QIntValidator(1, 65535, m_portEdit));
m_portEdit->setFixedWidth(50);
hnLayout->addWidget(m_portEdit);
m_portChecker = new WebRtpPortCheckerWidget;
hnLayout->addWidget(m_portChecker);
editsLayout->addLayout(hnLayout, 1, 1);
label = new QLabel(tr("Connection Type:"));
editsLayout->addWidget(label, 2, 0, Qt::AlignRight);
m_connectionType = new QComboBox;
m_connectionType->addItem(tr("RTSP"));
m_connectionType->addItem(tr("MJPEG"));
editsLayout->addWidget(m_connectionType, 2, 1);
label = new QLabel(tr("Username:"******"Password:"******"Connect Automatically"));
m_autoConnect->setChecked(true);
editsLayout->addWidget(m_autoConnect, 3, 1, 1, 1);
/* Errors */
m_connectionStatus = new QLabel;
m_connectionStatus->setAlignment(Qt::AlignCenter);
//m_connectionStatus->setContentsMargins(4, 4, 4, 4);
m_connectionStatus->setVisible(false);
mainLayout->addWidget(m_connectionStatus);
/* Buttons */
QFrame *line = new QFrame;
line->setFrameStyle(QFrame::HLine | QFrame::Sunken);
mainLayout->addWidget(line);
QBoxLayout *btnLayout = new QHBoxLayout;
mainLayout->addLayout(btnLayout);
QPushButton *newBtn = new QPushButton(tr("Add Server"));
newBtn->setAutoDefault(false);
connect(newBtn, SIGNAL(clicked()), SLOT(addNewServer()));
btnLayout->addWidget(newBtn);
QPushButton *delBtn = new QPushButton(tr("Delete"));
delBtn->setAutoDefault(false);
connect(delBtn, SIGNAL(clicked()), SLOT(deleteServer()));
btnLayout->addWidget(delBtn);
btnLayout->addStretch();
QPushButton *applyBtn = new QPushButton(tr("Apply"));
applyBtn->setAutoDefault(false);
connect(applyBtn, SIGNAL(clicked()), SLOT(saveChanges()));
btnLayout->addWidget(applyBtn);
connect(m_hostnameEdit, SIGNAL(editingFinished()), this, SLOT(checkServer()));
connect(m_portEdit, SIGNAL(editingFinished()), this, SLOT(checkServer()));
}
/*
* Syntax: CHECK <channel|nick|server|hostmask> [-flags]
*
* Where valid flags are:
* -c: Show channels when checking a hostmask.
* -i: Show IPs instead of hostnames when displaying results.
* -o: Only show channel operators when checking a channel.
* -u: Hide users when checking a channel.
*
* <hostmask> can be of the form host, user@host, nick!user@host,
* with host being host.domain.cc, 127.0.0.1 or 127.0.0.0/24.
* Wildcards are supported.
*/
int mo_check(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Channel *chptr;
struct Client *acptr;
int flags = CHECK_SHOWUSERS, i;
if (!HasPriv(sptr, PRIV_CHECK))
return send_reply(sptr, ERR_DISABLED, "CHECK");
if (parc < 2) {
send_reply(sptr, ERR_NEEDMOREPARAMS, "CHECK");
return 0;
}
if ( parc>=4 || (parc==3 && parv[2][0] != '-')) {
/* remote query */
if (hunt_server_cmd(sptr, CMD_CHECK, cptr, 0, parc==4 ? "%C %s %s" : "%C %s", 1, parc, parv) != HUNTED_ISME)
return 0;
parv++; parc--;
}
/* This checks to see if any flags have been supplied */
if ((parc >= 3) && (parv[2][0] == '-')) {
for (i = 0; parv[2][i]; i++) {
switch (parv[2][i]) {
case 'c':
flags |= CHECK_CHECKCHAN;
break;
case 'o':
flags |= CHECK_OPSONLY; /* fall through */
case 'u':
flags &= ~(CHECK_SHOWUSERS);
break;
case 'i':
flags |= CHECK_SHOWIPS;
break;
default:
/* might want to raise some sort of error here? */
break;
}
}
}
if (IsChannelName(parv[1])) /* channel */
{
if ((chptr = FindChannel(parv[1])))
{
checkChannel(sptr, chptr);
checkUsers(sptr, chptr, flags);
}
else
{
send_reply(sptr, ERR_SEARCHNOMATCH, "CHECK", parv[1]);
}
}
else if ((acptr = FindClient(parv[1])) && !(FindServer(parv[1]))) /* client and not a server */
{
if (!IsRegistered(acptr))
{
send_reply(sptr, ERR_SEARCHNOMATCH, "CHECK", parv[1]);
return 0;
}
checkClient(sptr, acptr);
}
else if ((acptr = FindServer(parv[1]))) { /* server */
checkServer(sptr, acptr);
}
else if (checkHostmask(sptr, parv[1], flags) > 0) /* hostmask */
return 1;
else /* no match */
send_reply(sptr, ERR_SEARCHNOMATCH, "CHECK", parv[1]);
return 1;
}
ErrVal
UDPController::initSender(char* confAdress, int confPort){
if( WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
{
printf("Client: WSAStartup failed with error %ld\n", WSAGetLastError());
// Clean up
WSACleanup();
// Exit with error
return -1;
}
else
//printf("Client: The Winsock DLL status is %s.\n", wsaData.szSystemStatus);
// Create a new socket to receive datagrams on.
SendingSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (SendingSocket == INVALID_SOCKET)
{
printf("Client: Error at socket(): %ld\n", WSAGetLastError());
// Clean up
WSACleanup();
// Exit with error
return -1;
}
//Define Internet adress
reciever_adress.sin_family = AF_INET;
reciever_adress.sin_addr.s_addr = inet_addr( confAdress );
port = confPort;
reciever_adress.sin_port = htons(port);
//
//server_length = sizeof(struct sockaddr_in);
//connect /bind
//printf("Prepare the Server\n");
system("pause");
checkServer();
//printf("Encoding preparation done, checking the reciever...\n");
//system("pause");
//printf("UDPController::init()\n");
return Err::m_nOK;
}
