CBaseEntity * CEntHost::GiveNamedItem( const char * szName, int iSubType, bool removeIfNotCarried )
{
// If I already own this type don't create one
if ( GetHost()->Weapon_OwnsThisType( szName, iSubType ) )
return NULL;
CBaseEntity *pEntity = CreateEntityByName( szName );
if ( !pEntity ) {
Msg( "NULL Ent in GiveNamedItem!\n" );
return NULL;
}
pEntity->SetLocalOrigin( GetLocalOrigin() );
pEntity->AddSpawnFlags( SF_NORESPAWN );
CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon *>(pEntity);
DispatchSpawn( pEntity );
if ( pWeapon ) {
pWeapon->SetSubType( iSubType );
GetHost()->Weapon_Equip( pWeapon );
}
else {
if ( pEntity && !(pEntity->IsMarkedForDeletion()) ) {
pEntity->Touch( GetHost() );
}
}
return pEntity;
}
const char* NNTPConnection::JoinGroup(const char* grp)
{
if (m_szActiveGroup && !strcmp(m_szActiveGroup, grp))
{
// already in group
strcpy(m_szLineBuf, "211 ");
return m_szLineBuf;
}
char tmp[1024];
snprintf(tmp, 1024, "GROUP %s\r\n", grp);
tmp[1024-1] = '\0';
const char* answer = Request(tmp);
if (answer && !strncmp(answer, "2", 1))
{
debug("Changed group to %s on %s", grp, GetHost());
if (m_szActiveGroup)
{
free(m_szActiveGroup);
}
m_szActiveGroup = strdup(grp);
}
else
{
debug("Error changing group on %s to %s: %s.", GetHost(), grp, answer);
}
return answer;
}
void CEntHost::Precache()
{
GetHost()->PrecacheModel( GetHostModel() );
GetHost()->PrecacheScriptSound( "Player.Death" );
GetHost()->PrecacheScriptSound( "Player.Pain" );
}
bool
PeerIdentity::Equals(const nsAString& aOtherString) const
{
nsString user;
GetUser(mPeerIdentity, user);
nsString otherUser;
GetUser(aOtherString, otherUser);
if (user != otherUser) {
return false;
}
nsString host;
GetHost(mPeerIdentity, host);
nsString otherHost;
GetHost(aOtherString, otherHost);
nsresult rv;
nsCOMPtr<nsIIDNService> idnService
= do_GetService("@mozilla.org/network/idn-service;1", &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return host == otherHost;
}
nsCString normHost;
GetNormalizedHost(idnService, host, normHost);
nsCString normOtherHost;
GetNormalizedHost(idnService, otherHost, normOtherHost);
return normHost == normOtherHost;
}
// Parts all insecure users on a +z channel (NOT KICK)
void f_part_insecure_users (aChannel *chptr)
{
Member *member, *mb2;
aClient *cptr;
char *comment = "Insecure user not allowed on secure channel (+z)";
for (member = chptr->members; member; member = mb2)
{
mb2 = member->next;
cptr = member->cptr;
if (MyClient(cptr) && !IsSecureConnect(cptr) && !IsULine(cptr))
{
RunHook4(HOOKTYPE_LOCAL_PART, cptr, &me, chptr, comment);
if ((chptr->mode.mode & MODE_AUDITORIUM) && is_chanownprotop(cptr, chptr))
{
sendto_chanops_butone(cptr, chptr, ":%s!%s@%s PART %s :%s",
cptr->name, cptr->user->username, GetHost(cptr), chptr->chname, comment);
sendto_prefix_one(cptr, &me, ":%s!%s@%s PART %s :%s",
cptr->name, cptr->user->username, GetHost(cptr), chptr->chname, comment);
}
else
{
sendto_channel_butserv(chptr, &me, ":%s!%s@%s PART %s :%s",
cptr->name, cptr->user->username, GetHost(cptr), chptr->chname, comment);
}
sendto_one(cptr, err_str(ERR_SECUREONLYCHAN), me.name, cptr->name, chptr->chname);
sendto_serv_butone_token(&me, cptr->name, MSG_PART, TOK_PART, "%s :%s", chptr->chname, comment);
remove_user_from_channel(cptr, chptr);
}
}
}
int CService::GetStatus () {
SC_HANDLE hSCM = NULL;
SC_HANDLE hService = NULL;
SERVICE_STATUS ss;
int nResult;
do {
if (!GetServiceName () || !GetHost () || !GetPort ()) {
nResult = SERVICE_STATUS_BAD_CONFIG;
break;
}
if (m_nWinsock) {
nResult = SERVICE_STATUS_BAD_WINSOCK;
SetLastError (m_nWinsock);
break;
}
hSCM = OpenSCManager (_scmHost (GetHost ()), NULL, GENERIC_READ);
if (!hSCM) {
nResult = SERVICE_STATUS_BAD_SCM;
break;
}
hService = OpenService (hSCM, GetServiceName (), SERVICE_INTERROGATE);
if (!hService) {
DWORD dwError = GetLastError ();
switch (dwError) {
case ERROR_SERVICE_DOES_NOT_EXIST :
nResult = SERVICE_STATUS_NOT_INSTALLED;
break;
default :
nResult = SERVICE_STATUS_CONNECTOR_ERROR;
break;
}
break;
}
if (!ControlService (hService, SERVICE_CONTROL_INTERROGATE, &ss)) {
DWORD dwError = GetLastError ();
switch (dwError) {
case ERROR_SERVICE_NEVER_STARTED :
case ERROR_SERVICE_NOT_ACTIVE :
nResult = SERVICE_STATUS_STOPPED;
break;
case ERROR_SERVICE_CANNOT_ACCEPT_CTRL :
nResult = SERVICE_STATUS_BUSY;
break;
default :
nResult = SERVICE_STATUS_QUERY_ERROR;
break;
}
break;
}
if (ss.dwCurrentState != SERVICE_RUNNING) {
nResult = SERVICE_STATUS_BUSY;
break;
}
nResult = _socketConnect (GetHost (), GetPort ()) ? SERVICE_STATUS_OK : SERVICE_STATUS_STARTING;
} while (FALSE);
if (hSCM) CloseServiceHandle (hSCM);
if (hService) CloseServiceHandle (hService);
return nResult;
}
void BaseAnimation::OnInit(void)
{
m_transform = (Transform*)GetHost()->FindComponent(CRC(0xF543030E, "Transform"));
if (!m_transform)
{
m_transform = (Transform*)GetHost()->FindComponentByType(CRC(0xF543030E, "Transform"));
}
Dbg_Assert(m_transform != NULL);
}
void ChatServerConnection::OnReceive(const char *pBuffer, uint32 nSize)
{
if (pBuffer) {
// Compose server message (we use the string copy constructor to ensure that there's a correct terminating zero)
const String sMessage = GetSocket().GetSocketAddress().GetHost() + ": '" + String(pBuffer, true, nSize-1) + '\''; // -1 = excluding the terminating zero
// Write the message into the log and start a new line
System::GetInstance()->GetConsole().Print(sMessage + '\n');
// Send message to all clients
for (uint32 i=0; i<GetHost().GetConnections().GetNumOfElements(); i++)
GetHost().GetConnections().Get(i)->Send(sMessage.GetASCII(), sMessage.GetLength()+1); // +1 so we also send the terminating zero
}
}
static void send_who_reply(aClient *sptr, aClient *acptr,
char *channel, char *status, char *xstat)
{
char *stat;
char *host;
int flat = (FLAT_MAP && !IsAnOper(sptr)) ? 1 : 0;
stat = malloc(strlen(status) + strlen(xstat) + 1);
sprintf(stat, "%s%s", status, xstat);
if (IsAnOper(sptr))
{
if (who_flags & WF_REALHOST)
host = acptr->user->realhost;
else if (who_flags & WF_IP)
host = (acptr->user->ip_str ? acptr->user->ip_str :
acptr->user->realhost);
else
host = GetHost(acptr);
}
else
host = GetHost(acptr);
if (IsULine(acptr) && !IsOper(sptr) && HIDE_ULINES)
sendto_one(sptr, getreply(RPL_WHOREPLY), me.name, sptr->name,
channel, /* channel name */
acptr->user->username, /* user name */
host, /* hostname */
"hidden", /* let's hide the server from normal users if the server is a uline and HIDE_ULINES is on */
acptr->name, /* nick */
stat, /* status */
0, /* hops (hidden) */
acptr->info /* realname */
);
else
sendto_one(sptr, getreply(RPL_WHOREPLY), me.name, sptr->name,
channel, /* channel name */
acptr->user->username, /* user name */
host, /* hostname */
acptr->user->server, /* server name */
acptr->name, /* nick */
stat, /* status */
flat ? 0 : acptr->hopcount, /* hops */
acptr->info /* realname */
);
free(stat);
}
void MultiViewerConnectDlg::OnOKButtonClick( wxCommandEvent& event )
{
wxString wxstrHost = GetHost();
if(wxstrHost.IsEmpty())
{
SQLUtil::AlertDlg(_T("No Host"));
return;
}
//wxString wxstrPort = GetPort();
//if(wxstrPort.IsEmpty())
//{
// SQLUtil::AlertDlg(_T("No Port"));
// return;
//}
//wxString wxstrName = GetName();
//if(wxstrName.IsEmpty())
//{
// SQLUtil::AlertDlg(_T("No ID"));
// return;
//}
//wxString wxstrPassword = GetPassword();
//if(wxstrPassword.IsEmpty())
//{
// SQLUtil::AlertDlg(_T("No Password"));
// return;
//}
EndModal(wxID_OK);
}
unsigned long long DzMilUnixTime()
{
DzHost* host = GetHost();
assert( host );
return (unsigned long long)MilUnixTime( host );
}
void RawFormatWidget::showEvent( QShowEvent *event )
{
if (!m_Format)
{
m_Format = GetHost()->NewFormat();
}
SourceInfo info;
rawSource->GetInfo(info);
ui.Title->setText(rawSource->GetPath());
ui.Width->setText(QString::number(info.format->Width()));
ui.Height->setText(QString::number(info.format->Height()));
int idx = 0;
for (int j=0; j<COLOR_COUNT; j++)
{
if (colors[j] == info.format->Color())
{
idx = j;
}
}
ui.Color->setCurrentIndex(idx);
ui.FPS->setValue(info.maxFps);
/*ui.Stride0->setText(QString::number(info.format->Stride(0)));
ui.Stride1->setText(QString::number(info.format->Stride(1)));
ui.Stride2->setText(QString::number(info.format->Stride(2)));
ui.Stride3->setText(QString::number(info.format->Stride(3)));*/
}
const char* NntpConnection::Request(const char* req)
{
if (!req)
{
return nullptr;
}
m_authError = false;
WriteLine(req);
char* answer = ReadLine(m_lineBuf, m_lineBuf.Size(), nullptr);
if (!answer)
{
return nullptr;
}
if (!strncmp(answer, "480", 3))
{
debug("%s requested authorization", GetHost());
if (!Authenticate())
{
return nullptr;
}
//try again
WriteLine(req);
answer = ReadLine(m_lineBuf, m_lineBuf.Size(), nullptr);
}
return answer;
}
bool NntpConnection::AuthInfoPass(int recur)
{
if (recur > 10)
{
return false;
}
WriteLine(BString<1024>("AUTHINFO PASS %s\r\n", m_newsServer->GetPassword()));
char* answer = ReadLine(m_lineBuf, m_lineBuf.Size(), nullptr);
if (!answer)
{
ReportErrorAnswer("Authorization failed for %s (%s): Connection closed by remote host", nullptr);
return false;
}
else if (!strncmp(answer, "2", 1))
{
debug("Authorization for %s successful", GetHost());
return true;
}
else if (!strncmp(answer, "381", 3))
{
return AuthInfoPass(++recur);
}
if (char* p = strrchr(answer, '\r')) *p = '\0'; // remove last CRLF from error message
if (GetStatus() != csCancelled)
{
ReportErrorAnswer("Authorization for %s (%s) failed: %s", answer);
}
return false;
}
void DzFreeEx( void* p )
{
DzHost* host = GetHost();
assert( host );
FreeEx( host, p );
}
unsigned long long DzLatestMilUnixTime()
{
DzHost* host = GetHost();
assert( host );
return (unsigned long long)host->latestMilUnixTime;
}
nsresult
nsPermissionManager::CommonTestPermission(nsIURI *aURI,
const char *aType,
PRUint32 *aPermission,
PRBool aExactHostMatch)
{
NS_ENSURE_ARG_POINTER(aURI);
NS_ENSURE_ARG_POINTER(aType);
// set the default
*aPermission = nsIPermissionManager::UNKNOWN_ACTION;
nsCAutoString host;
nsresult rv = GetHost(aURI, host);
// no host doesn't mean an error. just return the default
if (NS_FAILED(rv)) return NS_OK;
PRInt32 typeIndex = GetTypeIndex(aType, PR_FALSE);
// If type == -1, the type isn't known,
// so just return NS_OK
if (typeIndex == -1) return NS_OK;
nsHostEntry *entry = GetHostEntry(host, typeIndex, aExactHostMatch);
if (entry)
*aPermission = entry->GetPermission(typeIndex).mPermission;
return NS_OK;
}
NS_IMETHODIMP
nsSiteSecurityService::RemoveState(uint32_t aType, nsIURI* aURI, uint32_t aFlags)
{
// Should be called on the main thread (or via proxy) since the permission
// manager is used and it's not threadsafe.
NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_UNEXPECTED);
// Only HSTS is supported at the moment.
NS_ENSURE_TRUE(aType == nsISiteSecurityService::HEADER_HSTS,
NS_ERROR_NOT_IMPLEMENTED);
nsAutoCString hostname;
nsresult rv = GetHost(aURI, hostname);
NS_ENSURE_SUCCESS(rv, rv);
bool isPrivate = aFlags & nsISocketProvider::NO_PERMANENT_STORAGE;
rv = RemovePermission(hostname, STS_PERMISSION, isPrivate);
NS_ENSURE_SUCCESS(rv, rv);
SSSLOG(("SSS: deleted maxage permission\n"));
rv = RemovePermission(hostname, STS_SUBDOMAIN_PERMISSION, isPrivate);
NS_ENSURE_SUCCESS(rv, rv);
SSSLOG(("SSS: deleted subdomains permission\n"));
return NS_OK;
}
int __DzDbgLastErr()
{
DzHost* host = GetHost();
assert( host );
return __Dbg( GetLastErr )( host );
}
int __DzDbgSynObjLeak()
{
DzHost* host = GetHost();
assert( host );
return __Dbg( GetSynObjLeak )( host );
}
int __DzDbgParamNodeLeak()
{
DzHost* host = GetHost();
assert( host );
return __Dbg( GetParamNodeLeak )( host );
}
int __DzDbgHeapLeak()
{
DzHost* host = GetHost();
assert( host );
return __Dbg( GetHeapLeak )( host );
}
NS_IMETHODIMP
nsPermissionManager::Add(nsIURI *aURI,
const char *aType,
PRUint32 aPermission,
PRUint32 aExpireType,
PRInt64 aExpireTime)
{
NS_ENSURE_ARG_POINTER(aURI);
NS_ENSURE_ARG_POINTER(aType);
NS_ENSURE_TRUE(aExpireType == nsIPermissionManager::EXPIRE_NEVER ||
aExpireType == nsIPermissionManager::EXPIRE_TIME ||
aExpireType == nsIPermissionManager::EXPIRE_SESSION,
NS_ERROR_INVALID_ARG);
nsresult rv;
// Skip addition if the permission is already expired.
if (aExpireType == nsIPermissionManager::EXPIRE_TIME &&
aExpireTime <= PR_Now() / 1000)
return NS_OK;
nsCAutoString host;
rv = GetHost(aURI, host);
NS_ENSURE_SUCCESS(rv, rv);
return AddInternal(host, nsDependentCString(aType), aPermission, 0,
aExpireType, aExpireTime, eNotify, eWriteToDB);
}
BOOL CService::Start () {
SC_HANDLE hSCM = NULL;
SC_HANDLE hService = NULL;
BOOL bResult = FALSE;
do {
if (!GetServiceName ()) {
SetLastError (ERROR_BAD_CONFIGURATION);
break;
}
hSCM = OpenSCManager (_scmHost (GetHost ()), NULL, GENERIC_READ);
if (!hSCM) break;
hService = OpenService (hSCM, GetServiceName (), SERVICE_START);
if (!hService) break;
if (!StartService (hService, 0, NULL)) break;
bResult = TRUE;
} while (FALSE);
int nError = bResult ? 0 : GetLastError ();
if (hSCM) CloseServiceHandle (hSCM);
if (hService) CloseServiceHandle (hService);
if (bResult) {
return TRUE;
} else {
SetLastError (nError);
return FALSE;
}
}
void IPlugVST::HostSpecificInit()
{
if (!mHostSpecificInitDone)
{
mHostSpecificInitDone = true;
EHost host = GetHost();
switch (host)
{
case kHostAudition:
case kHostOrion:
case kHostForte:
case kHostSAWStudio:
LimitToStereoIO();
break;
default:
break;
}
// This won't always solve a picky host problem -- for example Forte
// looks at mAEffect IO count before identifying itself.
mAEffect.numInputs = mInputSpkrArr.numChannels = NInChannels();
mAEffect.numOutputs = mOutputSpkrArr.numChannels = NOutChannels();
OnHostIdentified();
}
}
BOOL CService::IsAutoStart () {
SC_HANDLE hSCM = NULL;
SC_HANDLE hService = NULL;
LPQUERY_SERVICE_CONFIG lpqsc = NULL;
BOOL bResult = FALSE;
do {
if (!GetServiceName ()) break;
hSCM = OpenSCManager (_scmHost (GetHost ()), NULL, GENERIC_READ);
if (!hSCM) break;
hService = OpenService (hSCM, GetServiceName (), SERVICE_QUERY_CONFIG);
if (!hService) break;
DWORD dwBytes = 1024;
do {
DWORD dwBytesNeeded;
lpqsc = (LPQUERY_SERVICE_CONFIG)new BYTE[dwBytes];
if (!lpqsc) break;
if (!QueryServiceConfig (hService, lpqsc, dwBytes, &dwBytesNeeded)) {
if (GetLastError () == ERROR_INSUFFICIENT_BUFFER) {
delete lpqsc;
lpqsc = NULL;
dwBytes = dwBytesNeeded;
continue;
}
}
break;
} while (TRUE);
if (!lpqsc) break;
bResult = (lpqsc->dwStartType == SERVICE_AUTO_START);
} while (FALSE);
if (hSCM) CloseServiceHandle (hSCM);
if (hService) CloseServiceHandle (hService);
return bResult;
}
int main(int argc, char ** argv)
{
int WebPort;
char * WebHost = 0, * PageAddress = 0, * WebDir = 0;
if(argc < 2) {if(DEBUG) fprintf(stdout, "Command error, you should input like this:\n\t%s WebPageAddress1 WebPageAddress2 WebPageAddress3 ...", argv[0]); exit(0);}
NodeHeader = NodeTail = NodeCurr = 0;
//开启mysql链接
mycon_init();
for(i = 1; i < argc; i++)
{
ret = GetHost(argv[i], &WebHost, &PageAddress, &WebPort, &WebDir); /* Get web page info */
if(ret) {if(DEBUG) fprintf(stdout, "GetHost error from '%s'\n", argv[i]); exit(0);}
AddInitNode(WebHost, PageAddress, WebPort, WebDir); /* add this page to chain */
}
free(WebHost); free(PageAddress);free(WebDir);
if(DEBUG)
{
fprintf(stdout, "\nDisplay.%5d:", FileNumber);
DisplayNode(NodeHeader); /* display every node */
}
HandleInitNode(NodeHeader); /* handle every page */
//关闭mysql链接
mycon_close();
return 0;
}
void ESP8266WebServerEx::redirect(const char* homePath) {
uint16_t port = g_ModuleSettings.data.port;
String url;
if ( !homePath ) return;
url.reserve(50);
url = "http://";
url += GetHost();
url += homePath;
String content;
content.reserve(250);
content = "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta http-equiv=\"refresh\" content=\"0; URL='";
content += url;
content += "'\" />\n<title>Login</title>\n</head>\n<body onload=\"window.location='";
content += url;
content += "';\">\n</body>\n</html>";
sendHeader("Location",url);
sendHeader("Cache-Control","no-cache");
sendHeader("Pragma","no-cache");
TRACE("Redirect...");
send(302,"text/html",content);
}
const char* NNTPConnection::Request(const char* req)
{
if (!req)
{
return NULL;
}
m_bAuthError = false;
WriteLine(req);
char* answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
if (!answer)
{
return NULL;
}
if (!strncmp(answer, "480", 3))
{
debug("%s requested authorization", GetHost());
if (!Authenticate())
{
return NULL;
}
//try again
WriteLine(req);
answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
}
return answer;
}
void* DzMallocEx( size_t size )
{
DzHost* host = GetHost();
assert( host );
return MallocEx( host, size );
}
