int
main(int argc, char** argv)
{
gRequestPort = find_port(kRequestPortName);
if (gRequestPort < B_OK) {
fprintf(stderr, "%s\n", strerror(gRequestPort));
return gRequestPort;
}
gReplyPort = find_port(kReplyPortName);
if (gReplyPort < B_OK) {
fprintf(stderr, "%s\n", strerror(gReplyPort));
return gReplyPort;
}
ReadSettings();
struct passwd* userInfo = getpwnam(kNobodyName);
if (userInfo != NULL)
gNobodyId = userInfo->pw_uid;
else
gNobodyId = 0;
struct group* groupInfo = getgrnam(kNogroupName);
if (groupInfo != NULL)
gNogroupId = groupInfo->gr_gid;
else
gNogroupId = 0;
return MainLoop();
}
unsigned int read_port_w(unsigned short port)
{
unsigned int r;
int i = find_port(port, IO_READ);
int j = find_port(port + 1, IO_READ);
#ifdef GUSPNP
if (port == 0x324)
i = j = 0;
#endif
/* FIXME: shoudl already be checked. ASSERT if i, j == -1 */
if (i == -1) {
i_printf("can't read low-byte of 16 bit port 0x%04x:trying to read high\n",
port);
return ((read_port(port + 1) << 8) | 0xff);
}
if (j == -1) {
i_printf("can't read hi-byte of 16 bit port 0x%04x:trying to read low\n",
port);
return (read_port(port) | 0xff00);
}
if (!video_port_io)
enter_priv_on();
if (port <= 0x3fe) {
set_ioperm(port, 2, 1);
} else
priv_iopl(3);
if (!video_port_io)
leave_priv_setting();
r = port_in_w(port);
if (!video_port_io)
enter_priv_on();
if (port <= 0x3fe)
set_ioperm(port, 2, 0);
else
priv_iopl(0);
if (!video_port_io)
leave_priv_setting();
if (
#ifdef GUSPNP
i && j &&
#endif
!video_port_io) {
r &= (ports[i].andmask | 0xff00);
r &= ((ports[j].andmask << 8) | 0xff);
r |= (ports[i].ormask & 0xff);
r |= ((ports[j].ormask << 8) & 0xff00);
} else
video_port_io = 0;
LOG_IO(port, r, '}', 0xffff);
i_printf("read 16 bit port 0x%x gave %04x at %04x:%04x\n",
port, r, LWORD(cs), LWORD(eip));
return (r);
}
struct expr *find_port(struct expr *e,char *name)
{
struct expr *r;
if(e)
if(e->t==',')
if(r=find_port(e->l,name)) return r;
else return find_port(e->r,name);
else if(e->t=='.' && e->l && e->l->t=='NAME' && !strcmp(e->l->str,name))
return e;
return 0;
}
void ensure_connected(jack_client_t *client, const char **ports, desired_connection *connection) {
const char *from_port_name = find_port(client, ports, connection->from_port);
const char *to_port_name = find_port(client, ports, connection->to_port);
// make sure both ports exist
if (from_port_name == NULL) {
printf("X from port (%s:%s) cannot be found\n", connection->from_port->desired,
mtype_strings[connection->from_port->which]);
return;
}
if (to_port_name == NULL) {
printf("X to port (%s:%s) cannot be found\n", connection->to_port->desired,
mtype_strings[connection->to_port->which]);
return;
}
jack_port_t *from_port, *to_port;
from_port = jack_port_by_name(client, from_port_name);
to_port = jack_port_by_name(client, to_port_name);
// this should never prematurely return, in theory
if (from_port == NULL || to_port == NULL) {
return;
}
const char **connections, **orig_connections;
orig_connections = connections = jack_port_get_all_connections(client, from_port);
printf("! connections for %s\n", from_port_name);
if (connections == NULL) {
printf("X --None\n");
}
int connected = 0;
while (connections && *connections) {
if (port_matcher(client, *connections, connection->to_port)) {
printf("! -->%s\n", *connections);
connected = 1;
break;
}
printf(" >%s\n", *connections);
*connections++;
}
if (connections != NULL) {
jack_free(orig_connections);
}
if (!connected) {
int rc;
printf("! Connecting %s to %s\n", from_port_name, to_port_name);
rc = jack_connect(client, from_port_name, to_port_name);
printf("%s rc is %d\n", rc == 0 ? "!" : "X", rc);
}
}
int write_port_w(unsigned int value, unsigned short port)
{
int i = find_port(port, IO_WRITE);
int j = find_port(port + 1, IO_WRITE);
#ifdef GUSPNP
if (port == 0x324)
i = j = 0;
#endif
if ((i == -1) || (j == -1)) {
i_printf("can't write to 16 bit port 0x%04x\n", port);
return 0;
}
if (
#ifdef GUSPNP
i && j &&
#endif
!video_port_io) {
value &= (ports[i].andmask | 0xff00);
value &= ((ports[j].andmask << 8) | 0xff);
value |= (ports[i].ormask & 0xff);
value |= ((ports[j].ormask << 8) & 0xff00);
}
i_printf("write 16 bit port 0x%x value %04x at %04x:%04x\n",
port, (value & 0xffff), LWORD(cs), LWORD(eip));
LOG_IO(port, value, '{', 0xffff);
if (!video_port_io)
enter_priv_on();
if (port <= 0x3fe)
set_ioperm(port, 2, 1);
else
priv_iopl(3);
if (!video_port_io)
leave_priv_setting();
port_out_w(value, port);
if (!video_port_io)
enter_priv_on();
if (port <= 0x3fe)
set_ioperm(port, 2, 0);
else
priv_iopl(0);
if (!video_port_io)
leave_priv_setting();
video_port_io = 0;
return (1);
}
uint64_t task_self_addr() {
if (cached_task_self_addr == 0) {
cached_task_self_addr = find_port(mach_task_self());
printf("task self: 0x%llx\n", cached_task_self_addr);
}
return cached_task_self_addr;
}
static struct snobj *queue_out_init(struct module *m, struct snobj *arg)
{
struct queue_out_priv *priv = get_priv(m);
struct snobj *t;
const char *port_name;
int ret;
if (!arg || snobj_type(arg) != TYPE_MAP)
return snobj_err(EINVAL, "Argument must be a map");
t = snobj_eval(arg, "port");
if (!t || !(port_name = snobj_str_get(t)))
return snobj_err(EINVAL, "Field 'port' must be specified");
t = snobj_eval(arg, "qid");
if (!t || snobj_type(t) != TYPE_INT)
return snobj_err(EINVAL, "Field 'qid' must be specified");
priv->qid = snobj_uint_get(t);
priv->port = find_port(port_name);
if (!priv->port)
return snobj_err(ENODEV, "Port %s not found", port_name);
ret = acquire_queues(priv->port, m, PACKET_DIR_OUT, &priv->qid, 1);
if (ret < 0)
return snobj_errno(-ret);
priv->send_pkts = priv->port->driver->send_pkts;
return NULL;
}
filter_result InputFilter::Filter(BMessage *message, BList *outList) {
const int32 kControlKeys = B_COMMAND_KEY | B_SHIFT_KEY;
if (message->what == B_KEY_DOWN ) {
int32 raw;
int32 mods;
if ((message->FindInt32("raw_char", 0, (int32 *)&raw) == B_OK)
&& (message->FindInt32("modifiers", (int32 *)&mods) == B_OK)
&& (raw==118) // v
&& ((mods & kControlKeys) == kControlKeys) ) {
port_id port = find_port("ClipUp input port");
if (port!=B_NAME_NOT_FOUND) {
write_port( port, 'CtSV', NULL, 0 );
return B_SKIP_MESSAGE;
}
}
}
return B_DISPATCH_MESSAGE;
}
//////////// ==
// Function to find a remote BLooper
BMessenger *SLooper::FindOtherEnd(char *unique_name) {
BMessenger *rc = new BMessenger();
int32 ignored;
FORMULATE_UNIQUE(unique_name);
// find port by name
port_id port = find_port(unique);
if (port < 0) {
return NULL;
}
// create a port for the reply
port_id myPort = create_port(1, "temporary port for answer");
// send the request to the other end with the port of our end
write_port(port, 0xdeadbeef, &myPort, sizeof(myPort));
// wait for an answer
ssize_t messageSize = port_buffer_size(myPort);
char *message = new char[messageSize];
read_port(myPort, &ignored, message, messageSize);
// get the BMessenger out of it
BMessage msg;
msg.Unflatten(message);
msg.FindMessenger("messageTarget", rc);
return rc;
}
static DBusMessage *port_disconnect(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct serial_device *device = user_data;
struct serial_port *port;
const char *dev, *owner, *caller;
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &dev,
DBUS_TYPE_INVALID) == FALSE)
return NULL;
port = find_port(device->ports, dev);
if (!port)
return does_not_exist(msg, "Port does not exist");
if (!port->listener_id)
return failed(msg, "Not connected");
owner = dbus_message_get_sender(port->msg);
caller = dbus_message_get_sender(msg);
if (!g_str_equal(owner, caller))
return failed(msg, "Operation not permited");
port_release(port);
g_dbus_remove_watch(conn, port->listener_id);
port->listener_id = 0;
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static int
config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format)
{
image_width = width;
image_height = height;
image_depth = 32;
image_size = (image_width * image_height * image_depth + 7) / 8;
aspect_save_orig(width,height);
aspect_save_prescale(d_width,d_height);
//printf("WinID=%d\n",WinID);
port=find_port("WID:12345");
if(port==B_NAME_NOT_FOUND || port==B_BAD_VALUE) {
haiku_wnd = new MWindow(image_width,image_height, title);
image_data=(unsigned char *)haiku_wnd->fb->GetBuffer();
haiku_wnd->Show();
if(flags&VOFLAG_FULLSCREEN) {
vo_fs=1;
if(haiku_wnd)
haiku_wnd->SetFullscreen(vo_fs);
}
} else {
image_data=(unsigned char *)malloc(image_size);
}
return 0;
}
//------------------------------------------------------------------------------
bool is_asst_running()
{
bool aRunning = true;
BEntry aEntry;
try {
if ( find_port(PORT_NAME_ASST_SPY) < 0 )
throw B_ERROR;
if ( find_port(PORT_NAME_ASST_PASTE_SENDER) < 0 )
throw B_ERROR;
} catch (...) {
aRunning = false;
}
// DBEXP("is_asst_running",aRunning);
return aRunning;
}
/* send:
* Send the given data block down the channel. `size' is in bytes.
* Return zero if successful, otherwise return non-zero. Don't bother
* checking that the packet arrived at the destination though.
*/
static int local_send(NET_CHANNEL *chan, const void *buf, int size)
{
channel_data_t *data;
port_t *target;
packet_t *packet;
if (size > MAX_PACKET_SIZE)
return -1;
/* Strictly, we should be locking the port's queue, but this will do. */
MUTEX_LOCK(port_list);
data = chan->data;
target = find_port(data->target);
if (target && (next_packet(target->head) != target->tail)) {
target->head = next_packet(target->head);
packet = &target->packets[target->head];
packet->from = data->port->num;
packet->size = size;
memcpy(packet->data, buf, size);
}
/* Errors and successes all end up here, because no delivery
* checking occurs on channels. */
MUTEX_UNLOCK(port_list);
return 0;
}
// init_connection
status_t
init_connection()
{
status_t error = B_OK;
// create a port
outputPort = create_port(10, "common test app port");
if (outputPort < 0)
error = outputPort;
// find the remote port
port_id port = -1;
if (error == B_OK) {
port = find_port(kAppRunnerTeamPort);
if (port < 0)
error = port;
}
// send the port ID
if (error == B_OK) {
ssize_t written = write_port(port, outputPort, &be_app_messenger,
sizeof(BMessenger));
if (written < 0)
error = written;
}
connectionEstablished = (error == B_OK);
return error;
}
/*****************************************************************************
* NAME:
* DESC:
* NOTE:
* SEE ALSO:
****************************************************************************/
port_id sys_find_port( const char *pzPortname )
{
port_id hPort;
hPort = find_port( pzPortname );
return ( hPort );
}
void
dns_portlist_remove(dns_portlist_t *portlist, int af, in_port_t port) {
dns_element_t *el;
REQUIRE(DNS_VALID_PORTLIST(portlist));
REQUIRE(af == AF_INET || af == AF_INET6);
LOCK(&portlist->lock);
if (portlist->active != 0) {
el = find_port(portlist->list, portlist->active, port);
if (el != NULL) {
if (af == AF_INET)
el->flags &= ~DNS_PL_INET;
else
el->flags &= ~DNS_PL_INET6;
if (el->flags == 0) {
*el = portlist->list[portlist->active];
portlist->active--;
qsort(portlist->list, portlist->active,
sizeof(*el), compare);
}
}
}
UNLOCK(&portlist->lock);
}
int port_register(DBusConnection *conn, const char *path, bdaddr_t *src,
bdaddr_t *dst, const char *uuid, uint8_t channel)
{
struct serial_device *device;
struct serial_port *port;
device = find_device(devices, path);
if (!device) {
device = create_serial_device(conn, path, src, dst);
if (!device)
return -1;
devices = g_slist_append(devices, device);
}
if (find_port(device->ports, uuid))
return 0;
port = g_new0(struct serial_port, 1);
port->uuid = g_strdup(uuid);
port->channel = channel;
port->device = device;
port->id = -1;
port->fd = -1;
device->ports = g_slist_append(device->ports, port);
return 0;
}
int
main(int argc, char** argv)
{
gRequestPort = find_port(kPortNameReq);
if (gRequestPort < B_OK) {
fprintf(stderr, "%s\n", strerror(gRequestPort));
return gRequestPort;
}
gReplyPort = find_port(kPortNameRpl);
if (gReplyPort < B_OK) {
fprintf(stderr, "%s\n", strerror(gReplyPort));
return gReplyPort;
}
return MainLoop();
}
status_t
PostEvent(bluetooth_device* ndev, void* event, size_t size)
{
struct hci_event_header* outgoingEvent = (struct hci_event_header*) event;
status_t err;
// Take actions on certain type of events.
switch (outgoingEvent->ecode) {
case HCI_EVENT_CONN_COMPLETE:
{
struct hci_ev_conn_complete* data
= (struct hci_ev_conn_complete*)(outgoingEvent + 1);
// TODO: XXX parse handle field
HciConnection* conn = AddConnection(data->handle, BT_ACL,
data->bdaddr, ndev->index);
if (conn == NULL)
panic("no mem for conn desc");
conn->ndevice = ndev;
TRACE("%s: Registered connection handle=%#x\n", __func__,
data->handle);
break;
}
case HCI_EVENT_DISCONNECTION_COMPLETE:
{
struct hci_ev_disconnection_complete_reply* data;
data = (struct hci_ev_disconnection_complete_reply*)
(outgoingEvent + 1);
RemoveConnection(data->handle, ndev->index);
TRACE("%s: unRegistered connection handle=%#x\n", __func__,
data->handle);
break;
}
}
// forward to bluetooth server
port_id port = find_port(BT_USERLAND_PORT_NAME);
if (port != B_NAME_NOT_FOUND) {
err = write_port_etc(port, PACK_PORTCODE(BT_EVENT, ndev->index, -1),
event, size, B_TIMEOUT, 1 * 1000 * 1000);
if (err != B_OK)
ERROR("%s: Error posting userland %s\n", __func__, strerror(err));
} else {
ERROR("%s: bluetooth_server not found for posting!\n", __func__);
err = B_NAME_NOT_FOUND;
}
return err;
}
static void
find_media_addon_server_port()
{
sMediaAddonServerPort = find_port(MEDIA_ADDON_SERVER_PORT_NAME);
if (sMediaAddonServerPort < 0) {
ERROR("couldn't find sMediaAddonServerPort\n");
sMediaAddonServerPort = BAD_MEDIA_ADDON_SERVER_PORT; // make this a unique number
}
}
int uhd_dpdk_set_ipv4_addr(unsigned int portid, uint32_t ipv4_addr, uint32_t netmask)
{
struct uhd_dpdk_port *p = find_port(portid);
if (p) {
p->ipv4_addr = ipv4_addr;
p->netmask = netmask;
return 0;
}
return -ENODEV;
}
//----------------------------------------------------------------------
static bool out_port_address(ea_t addr)
{
const char *name = find_port(addr);
if ( name != NULL )
{
out_line(name, COLOR_IMPNAME);
return true;
}
return false;
}
/*---------------------------------------------------------------------------*/
extern void lac_init_port(Lac_system *system, Port_no port_no,
Boolean lacp_enabled)
{
Lac_port *p;
if (find_port(system, port_no, &p))
{
init_port(p, lacp_enabled);
enable_port(p);
}
}
struct eth_addr uhd_dpdk_get_eth_addr(unsigned int portid)
{
struct eth_addr retval;
memset(retval.addr, 0xff, ETHER_ADDR_LEN);
struct uhd_dpdk_port *p = find_port(portid);
if (p) {
memcpy(retval.addr, p->mac_addr.addr_bytes, ETHER_ADDR_LEN);
}
return retval;
}
port_id
get_app_server_port()
{
if (sServerPort < 0) {
// No need for synchronization - in the worst case, we'll call
// find_port() twice.
sServerPort = find_port(SERVER_PORT_NAME);
}
return sServerPort;
}
// get_server_port
static
port_id
get_server_port()
{
static port_id id = -1;
static bool initialized = false;
if (!initialized) {
id = find_port(STAT_CACHE_SERVER_PORT_NAME);
initialized = true;
}
return id;
}
int uhd_dpdk_port_link_status(unsigned int portid)
{
if (!ctx)
return -ENODEV;
struct uhd_dpdk_port *p = find_port(portid);
if (p) {
struct rte_eth_link link;
rte_eth_link_get_nowait(p->id, &link);
return link.link_status;
}
return -ENODEV;
}
port_id
_user_find_port(const char *userName)
{
char name[B_OS_NAME_LENGTH];
if (userName == NULL)
return B_BAD_VALUE;
if (!IS_USER_ADDRESS(userName)
|| user_strlcpy(name, userName, B_OS_NAME_LENGTH) < B_OK)
return B_BAD_ADDRESS;
return find_port(name);
}
void nsToolkit::GetInterface()
{
if(! cached)
{
char portname[64];
PR_snprintf(portname, sizeof(portname), "event%lx",
(long unsigned) mGUIThreadID);
eventport = find_port(portname);
cached = true;
}
}
status_t
QuitConnectionPurgeThread()
{
status_t status;
port_id fPort = find_port(BLUETOOTH_CONNECTION_SCHED_PORT);
if (fPort != B_NAME_NOT_FOUND)
close_port(fPort);
flowf("Connection port deleted\n");
wait_for_thread(sConnectionThread, &status);
return status;
}
