160 lines
4.3 KiB
C
160 lines
4.3 KiB
C
#include "session.h"
|
|
#include <string.h>
|
|
|
|
static void clear_session(Session *session)
|
|
{
|
|
int role;
|
|
session->active = 0;
|
|
session->tag = 0;
|
|
for (role = 0; role < SESSION_CHANNELS; role++) {
|
|
session->descriptor[role] = -1;
|
|
}
|
|
}
|
|
|
|
void service_init(Service *service)
|
|
{
|
|
int index;
|
|
memset(service, 0, sizeof(*service));
|
|
device_init(&service->device);
|
|
for (index = 0; index < SESSION_SLOTS; index++) {
|
|
clear_session(&service->slot[index]);
|
|
}
|
|
for (index = 0; index < EXPORT_SLOTS; index++) {
|
|
service->exported[index] = -1;
|
|
}
|
|
}
|
|
|
|
static void close_bundle(Device *device, int descriptors[SESSION_CHANNELS])
|
|
{
|
|
int role;
|
|
for (role = SESSION_CHANNELS - 1; role >= 0; role--) {
|
|
if (descriptors[role] >= 0) {
|
|
device_close(device, descriptors[role]);
|
|
descriptors[role] = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int acquire_bundle(Service *service, int tag, unsigned fail_at,
|
|
int descriptors[SESSION_CHANNELS])
|
|
{
|
|
int role;
|
|
for (role = 0; role < SESSION_CHANNELS; role++) {
|
|
descriptors[role] = -1;
|
|
}
|
|
device_fault(&service->device, fail_at);
|
|
for (role = 0; role < SESSION_CHANNELS; role++) {
|
|
descriptors[role] = device_open(&service->device, tag, role);
|
|
if (descriptors[role] < 0) {
|
|
if (role == 0) {
|
|
close_bundle(&service->device, descriptors);
|
|
}
|
|
service->aborts++;
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void install_bundle(Service *service, Session *session, int tag,
|
|
const int descriptors[SESSION_CHANNELS])
|
|
{
|
|
int role;
|
|
for (role = 0; role < SESSION_CHANNELS; role++) {
|
|
session->descriptor[role] = descriptors[role];
|
|
}
|
|
session->active = 1;
|
|
session->tag = tag;
|
|
session->generation++;
|
|
service->commits++;
|
|
}
|
|
|
|
int service_open(Service *service, int slot, int tag, unsigned fail_at)
|
|
{
|
|
int descriptors[SESSION_CHANNELS];
|
|
Session *session = &service->slot[slot];
|
|
if (session->active) {
|
|
service->rejected++;
|
|
return -2;
|
|
}
|
|
if (acquire_bundle(service, tag, fail_at, descriptors) < 0) {
|
|
return -1;
|
|
}
|
|
install_bundle(service, session, tag, descriptors);
|
|
return 0;
|
|
}
|
|
|
|
void service_close(Service *service, int slot)
|
|
{
|
|
Session *session = &service->slot[slot];
|
|
if (!session->active) {
|
|
return;
|
|
}
|
|
close_bundle(&service->device, session->descriptor);
|
|
clear_session(session);
|
|
}
|
|
|
|
int service_replace(Service *service, int slot, int tag, unsigned fail_at)
|
|
{
|
|
int descriptors[SESSION_CHANNELS];
|
|
int previous[SESSION_CHANNELS];
|
|
int role;
|
|
Session *session = &service->slot[slot];
|
|
if (!session->active) {
|
|
service->rejected++;
|
|
return -2;
|
|
}
|
|
for (role = 0; role < SESSION_CHANNELS; role++) {
|
|
previous[role] = session->descriptor[role];
|
|
}
|
|
if (acquire_bundle(service, tag, fail_at, descriptors) < 0) {
|
|
return -1;
|
|
}
|
|
install_bundle(service, session, tag, descriptors);
|
|
close_bundle(&service->device, previous);
|
|
return 0;
|
|
}
|
|
|
|
int service_export(Service *service, int slot, int role, int target, unsigned fail_at)
|
|
{
|
|
int descriptor;
|
|
if (!service->slot[slot].active || service->exported[target] >= 0) {
|
|
service->rejected++;
|
|
return -2;
|
|
}
|
|
device_fault(&service->device, fail_at);
|
|
descriptor = device_dup(&service->device, service->slot[slot].descriptor[role]);
|
|
if (descriptor < 0) {
|
|
service->aborts++;
|
|
return -1;
|
|
}
|
|
service->exported[target] = descriptor;
|
|
return 0;
|
|
}
|
|
|
|
void service_release(Service *service, int target)
|
|
{
|
|
if (service->exported[target] >= 0) {
|
|
device_close(&service->device, service->exported[target]);
|
|
service->exported[target] = -1;
|
|
}
|
|
}
|
|
|
|
int service_send(Service *service, int slot, int role, int value)
|
|
{
|
|
if (!service->slot[slot].active) {
|
|
service->rejected++;
|
|
return -2;
|
|
}
|
|
return device_write(&service->device, service->slot[slot].descriptor[role], value);
|
|
}
|
|
|
|
int service_send_export(Service *service, int target, int value)
|
|
{
|
|
if (service->exported[target] < 0) {
|
|
service->rejected++;
|
|
return -2;
|
|
}
|
|
return device_write(&service->device, service->exported[target], value);
|
|
}
|