static int
cio_ignore_proc_seq_show(struct seq_file *s, void *it)
{
struct ccwdev_iter *iter;
iter = it;
if (!is_blacklisted(iter->ssid, iter->devno))
/* Not blacklisted, nothing to output. */
return 0;
if (!iter->in_range) {
/* First device in range. */
if ((iter->devno == __MAX_SUBCHANNEL) ||
!is_blacklisted(iter->ssid, iter->devno + 1))
/* Singular device. */
return seq_printf(s, "0.%x.%04x\n",
iter->ssid, iter->devno);
iter->in_range = 1;
return seq_printf(s, "0.%x.%04x-", iter->ssid, iter->devno);
}
if ((iter->devno == __MAX_SUBCHANNEL) ||
!is_blacklisted(iter->ssid, iter->devno + 1)) {
/* Last device in range. */
iter->in_range = 0;
return seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno);
}
return 0;
}
static int sierra_probe(struct usb_serial *serial,
const struct usb_device_id *id)
{
int result = 0;
struct usb_device *udev;
u8 ifnum;
udev = serial->dev;
ifnum = sierra_interface_num(serial);
/*
* If this interface supports more than 1 alternate
* select the 2nd one
*/
if (serial->interface->num_altsetting == 2) {
dev_dbg(&udev->dev, "Selecting alt setting for interface %d\n",
ifnum);
/* We know the alternate setting is 1 for the MC8785 */
usb_set_interface(udev, ifnum, 1);
}
if (is_blacklisted(ifnum,
(struct sierra_iface_info *)id->driver_info)) {
dev_dbg(&serial->dev->dev,
"Ignoring blacklisted interface #%d\n", ifnum);
return -ENODEV;
}
return result;
}
void AppList::generateAppList()
{
appLists.clear();
// list all portable kde3 apps
QDir kde3path( QDir::homePath() + "/.kde/share/apps");
QByteArray kdehome = qgetenv("KDEHOME");
if (kdehome.isEmpty())
kdehome = QDir::homePath().toUtf8() + "/.kde4/";
QDir kde4path( kdehome + "/share/apps");
for (QStringListIterator it(kde3path.entryList()); it.hasNext();) {
QByteArray app = QFile::encodeName(it.next());
if (app[0] == '.')
continue;
qDebug() << "looking at" << app;
bool blacklisted = is_blacklisted(app);
if (blacklisted)
continue;
qDebug() << "candidate: " << app;
AppListItem item;
item.appName = app;
item.dir = kde3path.path() + "/" + QFile::decodeName(app);
appLists << item;
}
}
bool is_blacklisted(attributes::function_def const& f)
{
if (is_blacklisted(f.return_type))
return true;
return std::any_of(f.parameters.cbegin(), f.parameters.cend(), [](attributes::parameter_def const& p) { return is_blacklisted(p.type); });
}
static int cio_check_devno_blacklisted(struct subchannel *sch)
{
if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) {
CIO_MSG_EVENT(6, "Blacklisted device detected "
"at devno %04X, subchannel set %x\n",
sch->schib.pmcw.dev, sch->schid.ssid);
return -ENODEV;
}
return 0;
}
static int cio_check_devno_blacklisted(struct subchannel *sch)
{
if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) {
/*
* This device must not be known to Linux. So we simply
* say that there is no device and return ENODEV.
*/
CIO_MSG_EVENT(6, "Blacklisted device detected "
"at devno %04X, subchannel set %x\n",
sch->schib.pmcw.dev, sch->schid.ssid);
return -ENODEV;
}
return 0;
}
void __print_func_entry(const char *func, const char *file)
{
char tentabs[] = "\t\t\t\t\t\t\t\t\t\t"; // ten tabs and a \0
char *ourtabs = &tentabs[10 - MIN(tab_depth, 10)];
if (!printx_on)
return;
if (is_blacklisted(func))
return;
spin_lock_irqsave(&lock);
__print_hdr();
printk("%s%s() in %s\n", ourtabs, func, file);
spin_unlock_irqsave(&lock);
tab_depth++;
}
void __print_func_entry(const char *func, const char *file)
{
if (!print)
return;
if (is_blacklisted(func))
return;
spinlock_lock(&lock);
printd("Vcore %2d", vcore_id()); /* helps with multicore output */
for (int i = 0; i < tab_depth; i++)
printf("\t");
printf("%s() in %s\n", func, file);
spinlock_unlock(&lock);
tab_depth++;
}
void __print_func_exit(const char *func, const char *file)
{
if (!print)
return;
if (is_blacklisted(func))
return;
tab_depth--;
spinlock_lock(&lock);
printd("Vcore %2d", vcore_id());
for (int i = 0; i < tab_depth; i++)
printf("\t");
printf("---- %s()\n", func);
spinlock_unlock(&lock);
}
size_t rewriteHandlers(std::string &local, std::set<std::string> &handlersSets)
{
HKEY localClassesKey = NULL;
if (RegOpenKeyExA(HKEY_USERS, local.c_str(), 0, KEY_READ | KEY_WRITE, &localClassesKey) != ERROR_SUCCESS) {
return 0;
}
size_t added = 0;
std::set<std::string>::iterator hItr;
for (hItr = handlersSets.begin(); hItr != handlersSets.end(); hItr++) {
std::string handlerName = *hItr;
if (is_blacklisted(handlerName)) {
continue;
}
if (!key_exist(localClassesKey, handlerName.c_str()) ) {
BYTE path_buffer[MAX_KEY_LENGTH];
DWORD val_len = MAX_KEY_LENGTH;
DWORD type;//RRF_RT_ANY
std::string commandKey = handlerName + "\\shell\\open\\command";
printf("+%s\n", commandKey.c_str());
if (!read_key(HKEY_CLASSES_ROOT, commandKey, path_buffer, val_len, type)) {
continue;
}
if (type != REG_SZ) {
continue;
}
if (is_path_blacklisted((char*) path_buffer)) {
printf("[BLACKLISTED] %s\n", path_buffer);
continue;
}
//
if (!write_key(localClassesKey, commandKey, path_buffer, val_len, type)) {
continue;
}
printf("[+] %s\n", path_buffer);
added++;
} else {
printf("Already exist: ");
printf("%s\n", handlerName.c_str());
}
}
RegCloseKey(localClassesKey);
return added;
}
/*
* cio_validate_subchannel()
*
* Find out subchannel type and initialize struct subchannel.
* Return codes:
* SUBCHANNEL_TYPE_IO for a normal io subchannel
* SUBCHANNEL_TYPE_CHSC for a chsc subchannel
* SUBCHANNEL_TYPE_MESSAGE for a messaging subchannel
* SUBCHANNEL_TYPE_ADM for a adm(?) subchannel
* -ENXIO for non-defined subchannels
* -ENODEV for subchannels with invalid device number or blacklisted devices
*/
int
cio_validate_subchannel (struct subchannel *sch, unsigned int irq)
{
char dbf_txt[15];
int ccode;
sprintf (dbf_txt, "valsch%x", irq);
CIO_TRACE_EVENT (4, dbf_txt);
/* Nuke all fields. */
memset(sch, 0, sizeof(struct subchannel));
spin_lock_init(&sch->lock);
/* Set a name for the subchannel */
snprintf (sch->dev.bus_id, BUS_ID_SIZE, "0.0.%04x", irq);
/*
* The first subchannel that is not-operational (ccode==3)
* indicates that there aren't any more devices available.
*/
sch->irq = irq;
ccode = stsch (irq, &sch->schib);
if (ccode)
return -ENXIO;
/* Copy subchannel type from path management control word. */
sch->st = sch->schib.pmcw.st;
/*
* ... just being curious we check for non I/O subchannels
*/
if (sch->st != 0) {
CIO_DEBUG(KERN_INFO, 0,
"Subchannel %04X reports "
"non-I/O subchannel type %04X\n",
sch->irq, sch->st);
/* We stop here for non-io subchannels. */
return sch->st;
}
/* Initialization for io subchannels. */
if (!sch->schib.pmcw.dnv)
/* io subchannel but device number is invalid. */
return -ENODEV;
/* Devno is valid. */
if (is_blacklisted (sch->schib.pmcw.dev)) {
/*
* This device must not be known to Linux. So we simply
* say that there is no device and return ENODEV.
*/
CIO_MSG_EVENT(0, "Blacklisted device detected "
"at devno %04X\n", sch->schib.pmcw.dev);
return -ENODEV;
}
sch->opm = 0xff;
chsc_validate_chpids(sch);
sch->lpm = sch->schib.pmcw.pim &
sch->schib.pmcw.pam &
sch->schib.pmcw.pom &
sch->opm;
CIO_DEBUG(KERN_INFO, 0,
"Detected device %04X on subchannel %04X"
" - PIM = %02X, PAM = %02X, POM = %02X\n",
sch->schib.pmcw.dev, sch->irq, sch->schib.pmcw.pim,
sch->schib.pmcw.pam, sch->schib.pmcw.pom);
/*
* We now have to initially ...
* ... set "interruption subclass"
* ... enable "concurrent sense"
* ... enable "multipath mode" if more than one
* CHPID is available. This is done regardless
* whether multiple paths are available for us.
*/
sch->schib.pmcw.isc = 3; /* could be smth. else */
sch->schib.pmcw.csense = 1; /* concurrent sense */
sch->schib.pmcw.ena = 0;
if ((sch->lpm & (sch->lpm - 1)) != 0)
sch->schib.pmcw.mp = 1; /* multipath mode */
return 0;
}
int main(int argc, char *argv[])
{
auto log = std::unique_ptr<sammy::log>(new sammy::log());
log->info("Starting server.");
unsigned int request_id = 1;
addrinfo* res = create_addrinfo();
int sockfd = create_socket(res);
set_socket_reusable(sockfd);
set_socket_bind(sockfd, res);
set_socket_non_blocking(sockfd);
set_socket_listen(sockfd);
int efd = create_epoll();
set_epoll_interface(efd, sockfd);
// Init the domain config loading
auto domain_storage = std::make_shared<sammy::domain_storage>();
if(domain_storage->errors())
{
log->error("Error loading config.");
exit(1);
}
// Init cache
auto cache = std::make_shared<sammy::cache_storage>();
// Init events
epoll_event* events = new epoll_event[MAX_EPOLL_EVENTS];
sammy::thread::pool thread_pool;
std::map<int, std::string> client_ip_address;
log->info("Server started");
while( true )
{
const int event_count = epoll_wait(efd, events, MAX_EPOLL_EVENTS, -1);
for(int i = 0; i < event_count; ++i)
{
const epoll_event& event = events[i];
if( (event.events & EPOLLERR) ||
(event.events & EPOLLHUP) ||
(!(event.events & EPOLLIN)))
{
std::cout << "Error in the file descriptor." << std::endl;
close(event.data.fd);
continue;
}
else if(sockfd == event.data.fd)
{
while( true )
{
sockaddr_in cli_addr;
socklen_t clilen{ sizeof(cli_addr) };
// Accept the the request
int newsockfd = accept(sockfd, (sockaddr*)&cli_addr, &clilen);
if(newsockfd == -1)
{
break;
}
set_socket_non_blocking(sockfd);
set_epoll_interface(efd, newsockfd);
std::string out;
inet_ntop(AF_INET, &(cli_addr.sin_addr), &out[0], INET_ADDRSTRLEN);
client_ip_address[newsockfd] = out;
}
continue;
}
else
{
int newsockfd = event.data.fd;
std::string client_address = client_ip_address[newsockfd];
std::string request_str = "";
size_t read_result = 0;
read_request(newsockfd, read_result, request_str);
// If the read result isn't ok
if(read_result == -1)
{
log->error("Error in read result, error #" + std::to_string(errno));
close(newsockfd);
continue;
}
// The request string is empty
if(request_str.empty())
{
log->error("Request string empty.");
close(newsockfd);
continue;
}
// Parse request string
auto client_request = std::make_shared<sammy::request>(request_id, request_str);
if(client_request->errors())
{
log->error("Request parse error: " + client_request->error_text());
close(newsockfd);
continue;
}
request_id++;
// Load domain configuration
std::string response = "";
auto domain = domain_storage->get_domain(client_request->get_host());
// If this server does not serve the domain being asked for, we close the connection.
if(!domain)
{
log->error(client_address + " : " + client_request->get_host() + " : " + client_request->get_method() + " : " + client_request->get_path() + " : Domain not served.");
close(newsockfd);
continue;
}
// If the client address is blacklisted, we close the connection.
if(domain->is_blacklisted(client_address))
{
log->error(client_address + " : " + client_request->get_host() + " : " + client_request->get_method() + " : " + client_request->get_path() + " : IP blacklisted.");
close(newsockfd);
continue;
}
// Add the task, to be processed by the thread pool when possible
thread_pool.add_task(std::make_shared<sammy::thread::task>(newsockfd, domain, client_request, cache, client_address));
continue;
}
}
}
delete [] events;
return 0;
}
void
gtk_inspector_python_init(void)
{
#ifdef ENABLE_PYTHON
int res;
struct sigaction old_sigint;
if (is_blacklisted())
return;
/* This prevents errors such as "undefined symbol: PyExc_ImportError" */
if (!dlopen(PYTHON_SHARED_LIB, RTLD_NOW | RTLD_GLOBAL))
{
g_error("%s\n", dlerror());
return;
}
captured_stdout = g_string_new("");
captured_stderr = g_string_new("");
/* Back up and later restore SIGINT so Python doesn't steal it from us. */
res = sigaction(SIGINT, NULL, &old_sigint);
if (!Py_IsInitialized())
Py_Initialize();
res = sigaction(SIGINT, &old_sigint, NULL);
Py_InitModule("gtk_inspector", gtk_inspector_python_methods);
PyRun_SimpleString(
"import gtk_inspector\n"
"import sys\n"
"\n"
"class StdoutCatcher:\n"
" def write(self, str):\n"
" gtk_inspector.capture_stdout(str)\n"
"\n"
"class StderrCatcher:\n"
" def write(self, str):\n"
" gtk_inspector.capture_stderr(str)\n"
"\n"
);
if (!pygobject_init(-1, -1, -1))
{
fprintf(stderr, "Error initializing pygobject support.\n");
PyErr_Print();
return;
}
char *argv[] = { "", NULL };
PySys_SetArgv(0, argv);
if (!PyImport_ImportModule("gi._gobject"))
{
PyErr_SetString(PyExc_ImportError, "could not import gi.gobject");
return;
}
if (!PyImport_ImportModule("gi.repository"))
{
PyErr_SetString(PyExc_ImportError, "could not import gi.repository");
return;
}
if (!PyImport_ImportModule("gi.repository.Gtk"))
{
PyErr_SetString(PyExc_ImportError, "could not import gtk");
return;
}
python_enabled = TRUE;
#endif // ENABLE_PYTHON
}