/* Higher level add of a one-wire-query object */
GOOD_OR_BAD OWQ_Cache_Add(const struct one_wire_query *owq)
{
const struct parsedname *pn = PN(owq);
if (pn->extension == EXTENSION_ALL) {
switch (pn->selected_filetype->format) {
case ft_ascii:
case ft_vascii:
case ft_alias:
case ft_binary:
return gbBAD; // cache of string arrays not supported
case ft_integer:
case ft_unsigned:
case ft_yesno:
case ft_date:
case ft_float:
case ft_pressure:
case ft_temperature:
case ft_tempgap:
LEVEL_DEBUG("Adding data for %s", SAFESTRING(pn->path) );
return Cache_Add(OWQ_array(owq), (pn->selected_filetype->ag->elements) * sizeof(union value_object), pn);
default:
return gbBAD;
}
} else {
switch (pn->selected_filetype->format) {
case ft_ascii:
case ft_vascii:
case ft_alias:
case ft_binary:
if (OWQ_offset(owq) > 0) {
return gbBAD;
}
LEVEL_DEBUG("Adding data for %s", SAFESTRING(pn->path) );
return Cache_Add(OWQ_buffer(owq), OWQ_length(owq), pn);
case ft_integer:
case ft_unsigned:
case ft_yesno:
case ft_date:
case ft_float:
case ft_pressure:
case ft_temperature:
case ft_tempgap:
LEVEL_DEBUG("Adding data for %s", SAFESTRING(pn->path) );
return Cache_Add(&OWQ_val(owq), sizeof(union value_object), pn);
default:
return gbBAD;
}
}
}
/* Choose in order:
* (first) 0x81
* (first) 0x01
* first other family
* 0x00
* */
GOOD_OR_BAD DS9490_ID_this_master(struct connection_in *in)
{
struct dirblob db ;
BYTE sn[SERIAL_NUMBER_SIZE] ;
int device_number ;
RETURN_BAD_IF_BAD( DS9490_root_dir( &db, in ) ) ;
// Use 0x00 if no devices (homegrown adapters?)
if ( DirblobElements( &db) == 0 ) {
DirblobClear( &db ) ;
memset( in->master.usb.ds1420_address, 0, SERIAL_NUMBER_SIZE ) ;
LEVEL_DEFAULT("Set DS9490 %s unique id 0x00 (no devices at all)", SAFESTRING(DEVICENAME(in))) ;
return gbGOOD ;
}
// look for the special 0x81 device
device_number = 0 ;
while ( DirblobGet( device_number, sn, &db ) == 0 ) {
if (sn[0] == 0x81) { // 0x81 family code
memcpy(in->master.usb.ds1420_address, sn, SERIAL_NUMBER_SIZE);
LEVEL_DEFAULT("Set DS9490 %s unique id to " SNformat, SAFESTRING(DEVICENAME(in)), SNvar(in->master.usb.ds1420_address));
DirblobClear( &db ) ;
return gbGOOD ;
}
++device_number ;
}
// look for the (less specific, for older DS9490s) 0x01 device
device_number = 0 ;
while ( DirblobGet( device_number, sn, &db ) == 0 ) {
if (sn[0] == 0x01) { // 0x01 family code
memcpy(in->master.usb.ds1420_address, sn, SERIAL_NUMBER_SIZE);
LEVEL_DEFAULT("Set DS9490 %s unique id to " SNformat, SAFESTRING(DEVICENAME(in)), SNvar(in->master.usb.ds1420_address));
DirblobClear( &db ) ;
return gbGOOD ;
}
++device_number ;
}
// Take the first device, whatever it is
DirblobGet( 0, sn, &db ) ;
memcpy(in->master.usb.ds1420_address, sn, SERIAL_NUMBER_SIZE);
LEVEL_DEFAULT("Set DS9490 %s unique id to " SNformat, SAFESTRING(DEVICENAME(in)), SNvar(in->master.usb.ds1420_address));
DirblobClear( &db ) ;
return gbGOOD;
}
/* Only error is if parsename fails */
GOOD_OR_BAD DS9490_root_dir( struct dirblob * db, struct connection_in * in )
{
ASCII path[PATH_MAX] ;
struct parsedname pn_root ;
UCLIBCLOCK;
/* Force this adapter with bus.n path */
snprintf(path, PATH_MAX, "/uncached/bus.%d", in->index);
UCLIBCUNLOCK;
if ( FS_ParsedName(path, &pn_root) != 0 ) {
LEVEL_DATA("Cannot get root directory on [%s] Parsing %s error.", SAFESTRING(DEVICENAME(in)), path);
return gbBAD ;
}
DirblobInit( db ) ;
/* First time pretend there are devices */
pn_root.selected_connection->changed_bus_settings |= CHANGED_USB_SPEED ; // Trigger needing new configuration
pn_root.selected_connection->overdrive = 0 ; // not overdrive at start
pn_root.selected_connection->flex = Globals.usb_flextime ;
SetReconnect(&pn_root) ;
FS_dir( DS9490_dir_callback, db, &pn_root ) ;
LEVEL_DEBUG("Finished FS_dir");
FS_ParsedName_destroy(&pn_root) ;
return gbGOOD ;
// Dirblob must be cleared by recipient.
}
static void WildLexCD(struct cd_parse_s *cps, ASCII * match)
{
struct parsedname pn;
LEVEL_DEBUG("FTP Wildcard patern matching: Path=%s, Pattern=%s, rest=%s", SAFESTRING(cps->buffer), SAFESTRING(match), SAFESTRING(cps->rest));
/* Check potential length */
if (strlen(cps->buffer) + OW_FULLNAME_MAX + 2 > PATH_MAX) {
cps->ret = -ENAMETOOLONG;
return;
}
if ( FS_ParsedName(cps->buffer, &pn) != 0 ) {
cps->ret = -ENOENT;
return;
}
if (!IsDir(&pn)) {
cps->ret = -ENOTDIR;
} else {
struct wildlexcd wlcd = { NULL, match, cps, };
int root = (cps->buffer[1] == '\0');
wlcd.end = &cps->buffer[strlen(cps->buffer)];
if (root) {
--wlcd.end;
}
wlcd.end[0] = '/';
FS_dir(WildLexCDCallback, &wlcd, &pn);
if (root) {
++wlcd.end;
}
wlcd.end[0] = '\0'; // restore cps->buffer
}
FS_ParsedName_destroy(&pn);
}
/* When the errors stop the USB device from functioning -- close and reopen.
* If it fails, re-scan the USB bus and search for the old adapter */
static GOOD_OR_BAD DS9490_reconnect(const struct parsedname *pn)
{
GOOD_OR_BAD ret;
struct connection_in * in = pn->selected_connection ;
if ( in->master.usb.specific_usb_address ) {
// special case where a usb bus:dev pair was given
// only connect to the same spot
return DS9490_redetect_specific_adapter( in ) ;
}
/* Have to protect usb_find_busses() and usb_find_devices() with
* a lock since libusb could crash if 2 threads call it at the same time.
* It's not called until DS9490_redetect_low(), but I lock here just
* to be sure DS9490_close() and DS9490_open() get one try first. */
LIBUSBLOCK;
DS9490_close( in ) ;
ret = DS9490_redetect_low(in) ;
LIBUSBUNLOCK;
if ( GOOD(ret) ) {
LEVEL_DEFAULT("Found USB DS9490 bus master after USB rescan as [%s]", SAFESTRING(DEVICENAME(in)));
}
return ret;
}
// This function should return number of bytes read... not status.
static SIZE_OR_ERROR FS_r_given_bus(struct one_wire_query *owq)
{
// Device locking occurs here
struct parsedname *pn = PN(owq);
SIZE_OR_ERROR read_or_error = 0;
LEVEL_DEBUG("About to read <%s> extension=%d size=%d offset=%d",SAFESTRING(pn->path),(int) pn->extension,(int) OWQ_size(owq),(int) OWQ_offset(owq));
if (KnownBus(pn) && BusIsServer(pn->selected_connection)) {
/* The bus is not local... use a network connection instead */
LEVEL_DEBUG("pid=%ld call ServerRead", pthread_self());
// Read afar -- returns already formatted in buffer
read_or_error = ServerRead(owq);
LEVEL_DEBUG("back from server");
//printf("FS_r_given_bus pid=%ld r=%d\n",pthread_self(), read_or_error);
} else {
STAT_ADD1(read_calls); /* statistics */
if (DeviceLockGet(pn) == 0) {
read_or_error = FS_r_local(owq); // this returns status
DeviceLockRelease(pn);
LEVEL_DEBUG("return=%d", read_or_error);
if (read_or_error >= 0) {
// local success -- now format in buffer
read_or_error = OWQ_parse_output(owq); // this returns nr. bytes
}
} else {
LEVEL_DEBUG("Cannot lock bus to perform read") ;
read_or_error = -EADDRINUSE;
}
}
LEVEL_DEBUG("After read is performed (bytes or error %d)", read_or_error);
Debug_OWQ(owq);
return read_or_error;
}
// Look on a given connection for the device
static INDEX_OR_ERROR CheckThisConnection(int bus_nr, struct parsedname *pn)
{
struct parsedname s_pn_copy;
struct parsedname * pn_copy = &s_pn_copy ;
struct connection_in * in = find_connection_in(bus_nr) ;
INDEX_OR_ERROR connection_result = INDEX_BAD ;
if ( in == NO_CONNECTION ) {
return INDEX_BAD ;
}
memcpy(pn_copy, pn, sizeof(struct parsedname)); // shallow copy
pn_copy->selected_connection = in;
if ( BAD( TestConnection(pn_copy) ) ) {
// Connection currently disconnected
return INDEX_BAD;
} else if (BusIsServer(in)) {
// Server
if ( INDEX_VALID( ServerPresence(pn_copy) ) ) {
connection_result = in->index;
}
} else if ( in->iroutines.flags & ADAP_FLAG_sham ) {
return INDEX_BAD ;
} else if ( in->iroutines.flags & ADAP_FLAG_presence_from_dirblob ) {
// local connection with a dirblob (like fake, mock, ...)
if ( GOOD( PresenceFromDirblob( pn_copy ) ) ) {
connection_result = in->index ;
}
} else {
// local connection but need to ask directly
struct transaction_log t[] = {
TRXN_NVERIFY,
TRXN_END,
};
if ( GOOD( BUS_transaction(t, pn_copy) ) ) {
connection_result = in->index ;
}
}
if ( connection_result == INDEX_BAD ) {
LEVEL_DEBUG("Presence of "SNformat" NOT found on bus %s",SNvar(pn_copy->sn),SAFESTRING(DEVICENAME(in))) ;
} else {
LEVEL_DEBUG("Presence of "SNformat" FOUND on bus %s",SNvar(pn_copy->sn),SAFESTRING(DEVICENAME(in))) ;
Cache_Add_Device(in->index,pn_copy->sn) ; // add or update cache */
}
return connection_result ;
}
int CompareContacts(WPARAM wParam, LPARAM lParam)
{
HANDLE a = (HANDLE) wParam,b = (HANDLE) lParam;
TCHAR namea[128], *nameb;
int statusa, statusb;
char *szProto1, *szProto2;
int rc;
szProto1 = (char*) CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM) a, 0);
szProto2 = (char*) CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM) b, 0);
statusa = DBGetContactSettingWord((HANDLE) a, SAFESTRING(szProto1), "Status", ID_STATUS_OFFLINE);
statusb = DBGetContactSettingWord((HANDLE) b, SAFESTRING(szProto2), "Status", ID_STATUS_OFFLINE);
if (sortByProto) {
/* deal with statuses, online contacts have to go above offline */
if ((statusa == ID_STATUS_OFFLINE) != (statusb == ID_STATUS_OFFLINE)) {
return 2 * (statusa == ID_STATUS_OFFLINE) - 1;
}
/* both are online, now check protocols */
rc = strcmp(SAFESTRING(szProto1), SAFESTRING(szProto2)); /* strcmp() doesn't like NULL so feed in "" as needed */
if (rc != 0 && (szProto1 != NULL && szProto2 != NULL))
return rc;
/* protocols are the same, order by display name */
}
if (sortByStatus) {
int ordera, orderb;
ordera = GetStatusModeOrdering(statusa);
orderb = GetStatusModeOrdering(statusb);
if (ordera != orderb)
return ordera - orderb;
} else {
//one is offline: offline goes below online
if ((statusa == ID_STATUS_OFFLINE) != (statusb == ID_STATUS_OFFLINE)) {
return 2 * (statusa == ID_STATUS_OFFLINE) - 1;
}
}
nameb = GetContactDisplayNameW(a, 0);
_tcsncpy(namea, nameb, safe_sizeof(namea));
namea[safe_sizeof(namea) - 1] = 0;
nameb = GetContactDisplayNameW(b, 0);
//otherwise just compare names
return CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, namea, -1, nameb, -1) - 2;
//return _tcsicmp(namea,nameb);
}
static INT_PTR CompareContacts(WPARAM wParam, LPARAM lParam)
{
MCONTACT a = wParam, b = lParam;
TCHAR namea[128], *nameb;
int statusa, statusb;
char *szProto1, *szProto2;
int rc;
szProto1 = GetContactProto(a);
szProto2 = GetContactProto(b);
statusa = db_get_w(a, SAFESTRING(szProto1), "Status", ID_STATUS_OFFLINE);
statusb = db_get_w(b, SAFESTRING(szProto2), "Status", ID_STATUS_OFFLINE);
if (sortByProto) {
/* deal with statuses, online contacts have to go above offline */
if ((statusa == ID_STATUS_OFFLINE) != (statusb == ID_STATUS_OFFLINE)) {
return 2 * (statusa == ID_STATUS_OFFLINE) - 1;
}
/* both are online, now check protocols */
rc = strcmp(SAFESTRING(szProto1), SAFESTRING(szProto2)); /* strcmp() doesn't like NULL so feed in "" as needed */
if (rc != 0 && (szProto1 != NULL && szProto2 != NULL))
return rc;
/* protocols are the same, order by display name */
}
if (sortByStatus) {
int ordera, orderb;
ordera = GetStatusModeOrdering(statusa);
orderb = GetStatusModeOrdering(statusb);
if (ordera != orderb)
return ordera - orderb;
}
else {
//one is offline: offline goes below online
if ((statusa == ID_STATUS_OFFLINE) != (statusb == ID_STATUS_OFFLINE)) {
return 2 * (statusa == ID_STATUS_OFFLINE) - 1;
}
}
nameb = cli.pfnGetContactDisplayName(a, 0);
_tcsncpy(namea, nameb, SIZEOF(namea));
namea[ SIZEOF(namea)-1 ] = 0;
nameb = cli.pfnGetContactDisplayName(b, 0);
//otherwise just compare names
return _tcsicmp(namea, nameb);
}
enum search_status BUS_first_alarm(struct device_search *ds, const struct parsedname *pn)
{
LEVEL_DEBUG("Start of directory path=%s device=" SNformat, SAFESTRING(pn->path), SNvar(pn->sn));
// reset the search state
BUS_first_both(ds);
ds->search = _1W_CONDITIONAL_SEARCH_ROM;
return BUS_next(ds, pn);
}
/* Used only in root_dir */
static void DS9490_dir_callback( void * v, const struct parsedname * pn_entry )
{
struct dirblob * db = v ;
LEVEL_DEBUG("Callback on %s",SAFESTRING(pn_entry->path));
if ( pn_entry->sn[0] != '\0' ) {
DirblobAdd( pn_entry->sn, db ) ;
}
}
void TrafficInFD( const char * data_type, const BYTE * data, size_t length, FILE_DESCRIPTOR_OR_ERROR file_descriptor )
{
struct connection_in * in = Bus_from_file_descriptor( file_descriptor ) ;
if ( in != NO_CONNECTION ) {
TrafficIn( data_type, data, length, in ) ;
} else {
fprintf(stderr, "TRAFFIC IN <%s> file descriptor=%d\n", SAFESTRING(data_type), file_descriptor ) ;
_Debug_Bytes( "FD", data, length ) ;
}
}
int CompareContacts( const struct ClcContact *contact1, const struct ClcContact *contact2 )
{
MCONTACT a = contact1->hContact, b = contact2->hContact;
TCHAR *namea,*nameb;
int statusa,statusb;
char *szProto1,*szProto2;
int rc;
GetContactInfosForSort(a,&szProto1,&namea,&statusa);
GetContactInfosForSort(b,&szProto2,&nameb,&statusb);
if (sortByProto) {
/* deal with statuses, online contacts have to go above offline */
if (sortNoOfflineBottom == 0)
if ((statusa == ID_STATUS_OFFLINE) != (statusb == ID_STATUS_OFFLINE)) {
return 2*(statusa == ID_STATUS_OFFLINE)-1;
}
/* both are online, now check protocols */
rc = strcmp(SAFESTRING(szProto1),SAFESTRING(szProto2)); /* strcmp() doesn't like NULL so feed in "" as needed */
if (rc != 0 && (szProto1 != NULL && szProto2 != NULL)) return rc;
/* protocols are the same, order by display name */
}
if (sortByStatus) {
int ordera,orderb;
ordera = GetStatusModeOrdering(statusa);
orderb = GetStatusModeOrdering(statusb);
if (ordera != orderb) return ordera-orderb;
}
else {
//one is offline: offline goes below online
if (sortNoOfflineBottom == 0)
{
if ((statusa == ID_STATUS_OFFLINE) != (statusb == ID_STATUS_OFFLINE)) {
return 2*(statusa == ID_STATUS_OFFLINE)-1;
}
}
}
//otherwise just compare names
return _tcsicmp(namea,nameb);
}
/* Create the Parsename structure and load the relevant fields */
struct one_wire_query * OWQ_create_sibling(const char *sibling, struct one_wire_query *owq_original)
{
char path[PATH_MAX] ;
struct parsedname * pn_original = PN(owq_original) ;
int dirlength = pn_original->dirlength ;
struct one_wire_query * owq_sib ;
strncpy(path, pn_original->path,dirlength) ;
strcpy(&path[dirlength],sibling) ;
if ( pn_original->selected_filetype == NO_FILETYPE ) {
if ( pn_original->subdir == NO_SUBDIR ) {
// not a filetype or a subdir
return NO_ONE_WIRE_QUERY ;
}
// Add extension only if original property is aggregate
} else if ( pn_original->selected_filetype->ag != NON_AGGREGATE ) {
// search for sibling in the filetype array
struct filetype * sib_filetype = bsearch(sibling, pn_original->selected_device->filetype_array,
(size_t) pn_original->selected_device->count_of_filetypes, sizeof(struct filetype), filetype_cmp) ;
// see if sibling is also an aggregate property
LEVEL_DEBUG("Path %s is an agggregate",SAFESTRING(pn_original->path));
if ( sib_filetype != NO_FILETYPE && sib_filetype->ag != NON_AGGREGATE ) {
char * aggregate_point = path + strlen(path) ;
LEVEL_DEBUG("Sibling is also an aggregate",sibling);
if (pn_original->extension == EXTENSION_BYTE ) {
strcpy( aggregate_point, ".BYTE" ) ;
} else if (pn_original->extension == EXTENSION_ALL ) {
strcpy( aggregate_point, ".ALL" ) ;
} else if (sib_filetype->ag->letters == ag_letters) {
UCLIBCLOCK;
snprintf(aggregate_point, OW_FULLNAME_MAX, ".%c", pn_original->extension + 'A');
UCLIBCUNLOCK;
} else {
UCLIBCLOCK;
snprintf(aggregate_point, OW_FULLNAME_MAX, ".%d", pn_original->extension );
UCLIBCUNLOCK;
}
}
}
LEVEL_DEBUG("Create sibling %s from %s as %s", sibling, pn_original->path,path);
owq_sib = OWQ_create_from_path(path) ;
if ( owq_sib != NO_ONE_WIRE_QUERY ) {
// Sib has no offset
OWQ_offset(owq_sib) = 0 ;
// Make uncached as restrictive as original
// Make unaliased as restrictive as original
PN(owq_sib)->state |= (pn_original->state & (ePS_uncached|ePS_unaliased) ) ;
return owq_sib ;
}
return NO_ONE_WIRE_QUERY ;
}
/* ---------------------------------------------- */
void FS_ParsedName_destroy(struct parsedname *pn)
{
if (!pn) {
return;
}
LEVEL_DEBUG("%s", SAFESTRING(pn->path));
CONNIN_RUNLOCK ;
Detail_Free( pn ) ;
SAFEFREE(pn->sparse_name);
SAFEFREE(pn->bp) ;
}
/* Open a DS9490 -- low level code (to allow for repeats) */
static GOOD_OR_BAD DS9490_redetect_match( struct connection_in * in)
{
struct dirblob db ;
BYTE sn[SERIAL_NUMBER_SIZE] ;
int device_number ;
LEVEL_DEBUG("Attempting reconnect on %s",SAFESTRING(DEVICENAME(in)));
// Special case -- originally untagged adapter
if ( in->master.usb.ds1420_address[0] == '\0' ) {
LEVEL_CONNECT("Since originally untagged bus master, we will use first available slot.");
return gbGOOD ;
}
// Generate a root directory
RETURN_BAD_IF_BAD( DS9490_root_dir( &db, in ) ) ;
// This adapter has no tags, so not the one we want
if ( DirblobElements( &db) == 0 ) {
DirblobClear( &db ) ;
LEVEL_DATA("Empty directory on [%s] (Doesn't match initial scan).", SAFESTRING(DEVICENAME(in)));
return gbBAD ;
}
// Scan directory for a match to the original tag
device_number = 0 ;
while ( DirblobGet( device_number, sn, &db ) == 0 ) {
if (memcmp(sn, in->master.usb.ds1420_address, SERIAL_NUMBER_SIZE) == 0) { // same tag device?
LEVEL_DATA("Matching device [%s].", SAFESTRING(DEVICENAME(in)));
DirblobClear( &db ) ;
return gbGOOD ;
}
++device_number ;
}
// Couldn't find correct ds1420 chip on this adapter
LEVEL_CONNECT("Couldn't find correct ds1420 chip on this bus master [%s] (want: " SNformat ")", SAFESTRING(DEVICENAME(in)), SNvar(in->master.usb.ds1420_address));
DirblobClear( &db ) ;
return gbBAD;
}
//open serial port ( called on head of connection_in group from com_open )
GOOD_OR_BAD serial_open(struct connection_in *connection)
{
struct port_in * pin = connection->pown ;
FILE_DESCRIPTOR_OR_ERROR fd = open( DEVICENAME(connection), O_RDWR | O_NONBLOCK | O_NOCTTY) ;
pin->file_descriptor = fd ;
if ( FILE_DESCRIPTOR_NOT_VALID( fd ) ) {
// state doesn't change
ERROR_DEFAULT("Cannot open port: %s Permissions problem?", SAFESTRING(DEVICENAME(connection)));
return gbBAD;
}
if ( pin->state == cs_virgin ) {
// valgrind warns about uninitialized memory in tcsetattr(), so clear all.
memset( &(pin->dev.serial.oldSerialTio), 0, sizeof(struct termios));
if ((tcgetattr( fd, &(pin->dev.serial.oldSerialTio) ) < 0)) {
ERROR_CONNECT("Cannot get old port attributes: %s", SAFESTRING(DEVICENAME(connection)));
// proceed anyway
}
pin->state = cs_deflowered ;
}
return serial_change( connection ) ;
}
/* return size if ok, else negative */
SIZE_OR_ERROR FS_write(const char *path, const char *buf, const size_t size, const off_t offset)
{
ZERO_OR_ERROR write_return;
OWQ_allocate_struct_and_pointer(owq);
LEVEL_CALL("path=%s size=%d offset=%d", SAFESTRING(path), (int) size, (int) offset);
// parsable path?
if ( OWQ_create(path, owq) != 0 ) { // for write
return -ENOENT;
}
OWQ_assign_write_buffer(buf, size, offset, owq) ;
write_return = FS_write_postparse(owq);
OWQ_destroy(owq);
return write_return; /* here's where the size is used! */
}
ZERO_OR_ERROR FS_fstat(const char *path, struct stat *stbuf)
{
struct parsedname pn;
ZERO_OR_ERROR ret = 0;
LEVEL_CALL("path=%s", SAFESTRING(path));
/* Bad path */
if (FS_ParsedName(path, &pn) != 0 ) {
return -ENOENT;
}
ret = FS_fstat_postparse(stbuf, &pn);
FS_ParsedName_destroy(&pn);
return ret;
}
SIZE_OR_ERROR FS_read(const char *path, char *buf, const size_t size, const off_t offset)
{
SIZE_OR_ERROR read_or_error;
OWQ_allocate_struct_and_pointer(owq);
LEVEL_CALL("path=%s size=%d offset=%d", SAFESTRING(path), (int) size, (int) offset);
// Parseable path?
if ( BAD( OWQ_create(path, owq) ) ) { // for read
return -ENOENT;
}
OWQ_assign_read_buffer( buf, size, offset, owq) ;
read_or_error = FS_read_postparse(owq);
OWQ_destroy(owq);
return read_or_error;
}
static int VISIBLE_19( const struct parsedname * pn )
{
int device_id = unknown_19 ;
LEVEL_DEBUG("Checking visibility of %s",SAFESTRING(pn->path)) ;
if ( BAD( GetVisibilityCache( &device_id, pn ) ) ) {
BYTE a_byte[1] ;
// use technique and address only specified on DS2407
if ( BAD( OW_r_all( a_byte, 1, 0x0080, pn ) ) ) {
device_id = ds2502_19 ;
} else {
device_id = ds2407_19 ;
}
SetVisibilityCache( device_id, pn ) ;
}
return device_id ;
}
/* Puts in 9600 baud */
static GOOD_OR_BAD DS9097_pre_reset(struct connection_in *in )
{
struct port_in * pin = in->pown ;
RETURN_BAD_IF_BAD( COM_test(in) ) ;
/* 8 data bits */
pin->bits = 8 ;
pin->baud = B9600 ;
if ( BAD( COM_change(in)) ) {
ERROR_CONNECT("Cannot set attributes: %s", SAFESTRING(DEVICENAME(in)));
DS9097_post_reset( in ) ;
return gbBAD;
}
return gbGOOD;
}
/* Sent back from Bonjour -- arbitrarily use it to set the Ref for Deallocation */
static void RegisterBack(DNSServiceRef s, DNSServiceFlags f, DNSServiceErrorType e, const char *name, const char *type, const char *domain, void *v)
{
struct connection_out * out = v ;
LEVEL_DETAIL
("RegisterBack ref=%d flags=%d error=%d name=%s type=%s domain=%s", s, f, e, SAFESTRING(name), SAFESTRING(type), SAFESTRING(domain));
if (e != kDNSServiceErr_NoError) {
return ;
}
out->sref0 = s;
SAFEFREE( out->zero.name ) ;
out->zero.name = owstrdup(name) ;
SAFEFREE( out->zero.type ) ;
out->zero.type = owstrdup(type) ;
SAFEFREE( out->zero.domain ) ;
out->zero.domain = owstrdup(domain) ;
}
/* This allows removing Bus Masters while program is running
* The master is usually only read-locked for normal operation
* write lock is done in a separate thread when no requests are being processed */
void Del_InFlight( GOOD_OR_BAD (*nomatch)(struct port_in * trial,struct port_in * existing), struct port_in * old_pin )
{
struct connection_in * old_in ;
if ( old_pin == NULL ) {
return ;
}
old_in = old_pin->first ;
LEVEL_DEBUG("Request master be removed: %s", DEVICENAME(old_in));
if ( nomatch != NULL ) {
struct port_in * pin ;
CONNIN_WLOCK ;
for ( pin = Inbound_Control.head_port ; pin != NULL ; pin = pin->next ) {
if ( BAD( nomatch( old_pin, pin )) ) {
LEVEL_DEBUG("Removing BUS index=%d %s",pin->first->index,SAFESTRING(DEVICENAME(pin->first)));
RemovePort(pin) ;
}
}
CONNIN_WUNLOCK ;
}
}
/* Check if device exists -- >=0 yes, -1 no */
INDEX_OR_ERROR CheckPresence(struct parsedname *pn)
{
INDEX_OR_ERROR bus_nr;
if (NotRealDir(pn)) {
return INDEX_DEFAULT;
}
if ((pn->selected_device == DeviceSimultaneous)
|| (pn->selected_device == DeviceThermostat)) {
return INDEX_DEFAULT;
}
/* If set, already found bus. */
/* Use UnsetKnownBus to clear and allow a new search */
if (KnownBus(pn)) {
return pn->known_bus->index;
}
if ( GOOD( Cache_Get_Device(&bus_nr, pn)) ) {
LEVEL_DEBUG("Found device on bus %d",bus_nr);
SetKnownBus(bus_nr, pn);
return bus_nr;
}
LEVEL_DETAIL("Checking presence of %s", SAFESTRING(pn->path));
bus_nr = CheckPresence_low(pn); // check only allocated inbound connections
if ( INDEX_VALID(bus_nr) ) {
SetKnownBus(bus_nr, pn);
Cache_Add_Device( bus_nr, pn->sn ) ;
return bus_nr;
}
UnsetKnownBus(pn);
return INDEX_BAD;
}
void TrafficIn( const char * data_type, const BYTE * data, size_t length, const struct connection_in * in )
{
fprintf(stderr, "TRAFFIC IN <%s> bus=%d (%s)\n", SAFESTRING(data_type), in->index, DEVICENAME(in) ) ;
_Debug_Bytes( in->adapter_name, data, length ) ;
}
int write_stats_dump(PRFileDesc *fd, StatsHeaderNode *hdr)
{
int i = 0;
StatsManager::lockStatsData();
const StatsHeader *hdrStats = &hdr->hdrStats;
// Version
PR_fprintf(fd, "\n%s\n", hdrStats->versionServer);
// Uptime
char buffer[25];
PRExplodedTime tm;
PR_ExplodeTime(hdrStats->timeStarted, PR_LocalTimeParameters, &tm);
PR_FormatTimeUSEnglish(buffer, sizeof(buffer), "%c", &tm);
PR_fprintf(fd, "\nServer started %s\n", buffer);
{
StatsProcessNode *process = hdr->process;
while (process) {
const StatsProcessSlot *procStats = &process->procStats;
PR_ExplodeTime(procStats->timeStarted, PR_LocalTimeParameters, &tm);
PR_FormatTimeUSEnglish(buffer, sizeof(buffer), "%c", &tm);
PR_fprintf(fd, "Process %d started %s\n", procStats->pid, buffer);
process = process->next;
}
}
// ConnectionQueue
{
StatsConnectionQueueSlot connqueues;
memset(&connqueues, 0, sizeof(connqueues));
// Accumulate connection queue buckets for every process
StatsProcessNode *process = hdr->process;
while (process) {
StatsConnectionQueueNode *connQueueNode = process->connQueue;
while (connQueueNode) {
const StatsConnectionQueueSlot *connqueue = &connQueueNode->connQueueStats;
connqueues.countQueued += connqueue->countQueued;
connqueues.peakQueued += connqueue->peakQueued;
connqueues.maxQueued += connqueue->maxQueued;
connqueues.countOverflows += connqueue->countOverflows;
connqueues.countTotalQueued += connqueue->countTotalQueued;
connqueues.ticksTotalQueued += connqueue->ticksTotalQueued;
connqueues.countTotalConnections += connqueue->countTotalConnections;
connqueues.countQueued1MinuteAverage += connqueue->countQueued1MinuteAverage;
connqueues.countQueued5MinuteAverage += connqueue->countQueued5MinuteAverage;
connqueues.countQueued15MinuteAverage += connqueue->countQueued15MinuteAverage;
connQueueNode = connQueueNode->next;
}
process = process->next;
}
PRFloat64 count = (PRInt64)connqueues.countTotalQueued;
PRFloat64 ticks = (PRInt64)connqueues.ticksTotalQueued;
if (count < 1.0)
count = 1.0;
PR_fprintf(fd,
"\nConnectionQueue:\n"
"-----------------------------------------\n"
"Current/Peak/Limit Queue Length %d/%d/%d\n"
"Total Connections Queued %llu\n"
"Average Queue Length (1, 5, 15 minutes) %4.2f, %4.2f, %4.2f\n"
"Average Queueing Delay %.2f milliseconds\n",
connqueues.countQueued, connqueues.peakQueued, connqueues.maxQueued,
connqueues.countTotalQueued,
connqueues.countQueued1MinuteAverage,
connqueues.countQueued5MinuteAverage,
connqueues.countQueued15MinuteAverage,
ticks / count / hdrStats->ticksPerSecond * 1000.0);
}
// Listen sockets
{
StatsProcessNode *process = hdr->process;
StatsListenNode *lsNode = (process) ? process->ls : 0;
while (lsNode) {
StatsListenSlot *ls = &lsNode->lsStats;
PRNetAddr addr;
memcpy(&addr, &ls->address, sizeof(ls->address));
char szAddress[512];
memset(szAddress, 0, sizeof(szAddress));
net_addr_to_string(&addr, szAddress, sizeof(szAddress)-1);
PR_fprintf(fd,
"\nListenSocket %s:\n"
"------------------------\n"
"Address %s://%s:%hu\n"
"Acceptor Threads %d\n"
"Default Virtual Server %s\n",
ls->id,
ls->flagSecure ? "https" : "http",
szAddress,
PR_ntohs(ls->address.inet.port),
ls->countAcceptors,
ls->defaultVsId
);
lsNode = lsNode->next;
}
}
// Keepalive Info
{
StatsKeepaliveBucket keepalives;
memset(&keepalives, 0, sizeof(keepalives));
// Accumulate keepalive buckets for every process
StatsProcessNode *process = hdr->process;
while (process) {
StatsKeepaliveBucket *procKeepAlive = NULL;
procKeepAlive = &process->procStats.keepAliveBucket;
StatsManagerUtil::accumulateKeepAlive(&keepalives, procKeepAlive);
process = process->next;
}
PR_fprintf(fd,
"\nKeepAliveInfo:\n"
"--------------------\n"
"KeepAliveCount %lu/%lu\n"
"KeepAliveHits %llu\n"
"KeepAliveFlushes %llu\n"
"KeepAliveRefusals %llu\n"
"KeepAliveTimeouts %llu\n"
"KeepAliveTimeout %lu seconds\n",
keepalives.countConnections,
keepalives.maxConnections,
keepalives.countHits,
keepalives.countFlushes,
keepalives.countRefusals,
keepalives.countTimeouts,
keepalives.secondsTimeout);
}
// Session Creation Info
{
PRUint32 countThreads = 0;
PRUint32 countBusy = 0;
PRUint32 countKeepAlive = 0;
PRUint32 countKeepAliveThreads = 0;
// Count the number of active threads
StatsProcessNode *process = hdr->process;
while (process) {
StatsProcessSlot *procStats = &process->procStats;
if (procStats->mode != STATS_PROCESS_EMPTY) {
StatsThreadNode *thread = process->thread;
while (thread) {
const StatsThreadSlot *threadStats = &thread->threadStats;
if (threadStats->mode != STATS_THREAD_EMPTY) {
countThreads++;
if (threadStats->mode == STATS_THREAD_KEEPALIVE) {
countKeepAlive++;
} else if (threadStats->mode != STATS_THREAD_IDLE) {
countBusy++;
}
}
thread = thread->next;
}
}
// Get number of keepalive threads
StatsKeepaliveBucket *procKeepAlive = NULL;
procKeepAlive = &process->procStats.keepAliveBucket;
countKeepAliveThreads += procKeepAlive->numThreads;
process = process->next;
}
PR_fprintf(fd,
"\nSessionCreationInfo:\n"
"------------------------\n"
"Active Sessions %lu\n"
"Keep-Alive Sessions %lu\n"
"Total Sessions Created %lu/%lu\n",
countBusy,
countKeepAlive,
countThreads, (hdrStats->maxThreads * hdrStats->maxProcs + countKeepAliveThreads));
}
// Cache Info
{
StatsCacheBucket caches;
memset(&caches, 0, sizeof(caches));
// Accumulate cache buckets for every process
StatsProcessNode *process = hdr->process;
while (process) {
StatsCacheBucket *procCache = NULL;
procCache = &process->procStats.cacheBucket;
StatsManagerUtil::accumulateCache(&caches, procCache);
process = process->next;
}
if (caches.flagEnabled) {
PR_fprintf(fd,
"\nCacheInfo:\n"
"-----------------------\n");
PRInt64 fileLookups = caches.countHits + caches.countMisses;
PR_fprintf(fd,
"File Cache Enabled yes\n"
"File Cache Entries %lu/%lu\n"
"File Cache Hit Ratio %llu/%lld (%6.2f%%)\n"
"Maximum Age %d\n",
caches.countEntries,
caches.maxEntries,
caches.countHits,
fileLookups,
percent(caches.countHits, fileLookups),
caches.secondsMaxAge);
PRInt64 accelRequests = caches.countAcceleratableRequests + caches.countUnacceleratableRequests;
PRInt64 accelResponses = caches.countAcceleratableResponses + caches.countUnacceleratableResponses;
PRInt64 accelLookups = caches.countAcceleratorHits + caches.countAcceleratorMisses;
PR_fprintf(fd,
"Accelerator Entries %lu/%lu\n"
"Acceleratable Requests %llu/%lld (%6.2f%%)\n"
"Acceleratable Responses %llu/%lld (%6.2f%%)\n"
"Accelerator Hit Ratio %llu/%lld (%6.2f%%)\n",
caches.countAcceleratorEntries,
caches.maxEntries,
caches.countAcceleratableRequests,
accelRequests,
percent(caches.countAcceleratableRequests, accelRequests),
caches.countAcceleratableResponses,
accelResponses,
percent(caches.countAcceleratableResponses, accelResponses),
caches.countAcceleratorHits,
accelLookups,
percent(caches.countAcceleratorHits, accelLookups));
} else {
PR_fprintf(fd, "\nServer cache disabled\n");
}
}
// Thread pool info
{
StatsThreadPoolBucket pools[FUNC_MAXPOOLS];
const char *names[FUNC_MAXPOOLS];
memset(pools, 0, sizeof(pools));
memset(names, 0, sizeof(names));
// Accumulate thread pool buckets for every process
StatsProcessNode *process = hdr->process;
while (process) {
StatsThreadPoolNode *pool = process->threadPool;
for (i = 0; pool && (i < FUNC_MAXPOOLS); i++) {
StatsManagerUtil::accumulateThreadPool(&pools[i],
&pool->threadPoolStats);
names[i] = STATS_GET_NAME(&pool->threadPoolStats);
pool = pool->next;
}
process = process->next;
}
int poolFlag = 0;
for (i = 0; i < FUNC_MAXPOOLS; i++)
{
if (names[i]) {
if (!poolFlag)
{
poolFlag = 1;
PR_fprintf(fd,
"\nNative pools:\n"
"----------------------------\n");
}
PR_fprintf(fd,
"%s:\n"
"Idle/Peak/Limit %lu/%lu/%lu\n"
"Work Queue Length/Peak/Limit %lu/%lu/%lu\n",
names[i],
pools[i].countThreadsIdle,
pools[i].countThreads,
pools[i].maxThreads,
pools[i].countQueued,
pools[i].peakQueued,
pools[i].maxQueued);
}
}
}
// DNS info
{
StatsDnsBucket dnss;
memset(&dnss, 0, sizeof(dnss));
// Accumulate DNS buckets for every process
StatsProcessNode *process = hdr->process;
while (process) {
StatsManagerUtil::accumulateDNS(&dnss,
&process->procStats.dnsBucket);
process = process->next;
}
if (dnss.flagCacheEnabled) {
PRUint32 totalhits = dnss.countCacheMisses + dnss.countCacheHits;
float hitratio;
if (totalhits > 0.0)
hitratio = (float)dnss.countCacheHits / (float)totalhits;
else
hitratio = 0.0;
PR_fprintf(fd,
"\nDNSCacheInfo:\n"
"------------------\n"
"enabled yes\n"
"CacheEntries %lu/%lu\n"
"HitRatio %lu/%lu (%6.2f%%)\n",
dnss.countCacheEntries,
dnss.maxCacheEntries,
dnss.countCacheHits,
totalhits,
hitratio * 100.0);
} else {
PR_fprintf(fd, "\nServer DNS cache disabled\n");
}
if (dnss.flagAsyncEnabled) {
PR_fprintf(fd,
"\nAsyncDNS Data:\n"
"------------------\n"
"enabled yes\n"
"NameLookups %lu\n"
"AddrLookups %lu\n"
"LookupsInProgress %lu\n",
dnss.countAsyncNameLookups,
dnss.countAsyncAddrLookups,
dnss.countAsyncLookupsInProgress);
} else {
PR_fprintf(fd, "\nAsync DNS disabled\n");
}
}
// NSAPI Profile Info
if (hdrStats->maxProfileBuckets) {
int i;
StatsProfileBucket *profiles = new StatsProfileBucket[hdrStats->maxProfileBuckets];
const char **names = new const char*[hdrStats->maxProfileBuckets];
const char **descs = new const char*[hdrStats->maxProfileBuckets];
memset(profiles, 0, sizeof(profiles[0]) * hdrStats->maxProfileBuckets);
memset(names, 0, sizeof(names[0]) * hdrStats->maxProfileBuckets);
memset(descs, 0, sizeof(descs[0]) * hdrStats->maxProfileBuckets);
// Accumulate profiles for every thread
StatsProcessNode *process = hdr->process;
while (process) {
StatsThreadNode *thread = process->thread;
while (thread) {
StatsProfileNode *profile = thread->profile;
for (i = 0; i < hdrStats->maxProfileBuckets; i++) {
StatsManagerUtil::accumulateProfile(&profiles[i],
&profile->profileStats);
names[i] = STATS_GET_NAME(&profile->profileStats);
descs[i] = STATS_GET_DESCRIPTION(&profile->profileStats);
profile = profile->next;
}
thread = thread->next;
}
process = process->next;
}
PRInt64 tr = profiles[STATS_PROFILE_ALL].countRequests;
PRInt64 tc = profiles[STATS_PROFILE_ALL].countCalls;
float td = (float)(PRInt64)profiles[STATS_PROFILE_ALL].ticksDispatch;
float tf = (float)(PRInt64)profiles[STATS_PROFILE_ALL].ticksFunction;
td /= hdrStats->ticksPerSecond;
tf /= hdrStats->ticksPerSecond;
float tt = td + tf;
PR_fprintf(fd,
"\nPerformance Counters:\n"
"------------------------------------------------\n"
" Average Total Percent\n\n"
"Total number of requests: %10llu\n"
"Request processing time: %7.4f %12.4f\n",
tr,
(tr > 0) ? (tt / (float)tr) : 0, tt);
for (i = hdrStats->maxProfileBuckets-1; i >= STATS_PROFILE_DEFAULT; i--) {
PRInt64 r = profiles[i].countRequests;
PRInt64 c = profiles[i].countCalls;
const char *name = names[i];
// Don't display cache-bucket if it's empty. This is a predefined
// bucket that stored NSAPI accelerator cache statistics in
// previous versions of the server.
if (!c && i == STATS_PROFILE_CACHE && !strcmp(name, "cache-bucket")) {
continue;
}
float d = (float)(PRInt64)profiles[i].ticksDispatch;
float f = (float)(PRInt64)profiles[i].ticksFunction;
d /= hdrStats->ticksPerSecond;
f /= hdrStats->ticksPerSecond;
float t = d + f;
PR_fprintf(fd,
"\n%s (%s)\n"
"Number of Requests: %12llu (%6.2f%%)\n"
"Number of Invocations: %12llu (%6.2f%%)\n"
"Latency: %7.4f %12.4f (%6.2f%%)\n"
"Function Processing Time: %7.4f %12.4f (%6.2f%%)\n"
"Total Response Time: %7.4f %12.4f (%6.2f%%)\n",
name, SAFESTRING(descs[i]),
r, (tr > 0) ? (100.0 * r / (PRFloat64) tr) : 0,
c, (tc > 0) ? (100.0 * c / (PRFloat64) tc) : 0,
(r > 0)? (d / r): 0, d, (tt > 0)? (100 * d / tt): 0,
(r > 0)? (f / r): 0, f, (tt > 0)? (100 * f / tt): 0,
(r > 0)? (t / r): 0, t, (tt > 0)? (100 * t / tt): 0);
}
delete[] profiles;
delete[] names;
delete[] descs;
} else {
PR_fprintf(fd, "\nPerformance Statistics disabled\n");
}
// Session info
{
StatsProcessNode *process;
int x;
int y;
// Count the number of rows in our session table
int nr = 0;
for (process = hdr->process; process; process = process->next) {
StatsThreadNode *thread;
for (thread = process->thread; thread; thread = thread->next)
nr++;
}
SessionRow *rows = new SessionRow[nr];
PRTime now = PR_Now();
// Collect stats from each session
y = 0;
for (process = hdr->process; process; process = process->next) {
StatsThreadNode *thread;
for (thread = process->thread; thread; thread = thread->next) {
thread->lock();
PRUint32 mode = thread->threadStats.mode;
if (mode != STATS_THREAD_EMPTY && mode != STATS_THREAD_IDLE &&
mode != STATS_THREAD_KEEPALIVE) {
rows[y].columns[SESSION_COLUMN_PROCESS].printf("%u", process->procStats.pid);
rows[y].columns[SESSION_COLUMN_STATUS] = StatsManager::getMode(&thread->threadStats);
char addr[NET_ADDR_STRING_SIZE];
net_addr_to_string(&thread->threadStats.addressClient, addr, sizeof(addr));
rows[y].columns[SESSION_COLUMN_CLIENT] = addr;
rows[y].timeRequestStarted = thread->threadStats.timeRequestStarted;
if (rows[y].timeRequestStarted != 0) {
PRTime microseconds = now - rows[y].timeRequestStarted;
int seconds = (microseconds + PR_USEC_PER_SEC/2) / PR_USEC_PER_SEC;
rows[y].columns[SESSION_COLUMN_AGE].printf("%d", seconds);
}
rows[y].columns[SESSION_COLUMN_VS] = thread->threadStats.vsId;
rows[y].columns[SESSION_COLUMN_METHOD] = thread->threadStats.requestBucket.method;
rows[y].columns[SESSION_COLUMN_URI] = thread->threadStats.requestBucket.uri;
rows[y].columns[SESSION_COLUMN_FUNCTION] = STATS_GET_FUNCTION_NAME(&thread->threadStats);
y++;
}
thread->unlock();
}
}
// We'll only display stats for active sessions
PR_ASSERT(y <= nr);
nr = y;
// Each column is at least as wide as its label
int widths[SESSION_COLUMN_COUNT];
for (x = 0; x < SESSION_COLUMN_COUNT; x++)
widths[x] = session_column_labels[x].length();
// Ensure each column is wide enough to fit its largest value
for (y = 0; y < nr; y++) {
for (x = 0; x < SESSION_COLUMN_COUNT; x++) {
if (widths[x] < rows[y].columns[x].length())
widths[x] = rows[y].columns[x].length();
}
}
// Leave at least 2 spaces between columns
for (x = 0; x < SESSION_COLUMN_COUNT - 1; x++)
widths[x] += 2;
// Calculate total line width and individual column offsets
int width = 0;
int offsets[SESSION_COLUMN_COUNT];
for (x = 0 ; x < SESSION_COLUMN_COUNT; x++) {
offsets[x] = width;
width += widths[x];
}
char *line = (char *) malloc(width + sizeof('\n'));
// Output table heading and column labels
PR_fprintf(fd, "\nSessions:\n");
memset(line, '-', width);
line[width] = '\n';
PR_Write(fd, line, width + sizeof('\n'));
PR_Write(fd, line, format_session(line, offsets, session_column_labels));
PR_Write(fd, "\n", 1);
// Sort rows by age
const SessionRow **sorted = new const SessionRow *[nr];
for (y = 0; y < nr; y++)
sorted[y] = &rows[y];
qsort(sorted, nr, sizeof(sorted[0]), &session_cmp);
// Output individual rows
for (y = 0; y < nr; y++)
PR_Write(fd, line, format_session(line, offsets, sorted[y]->columns));
delete [] sorted;
free(line);
delete [] rows;
}
StatsManager::unlockStatsData();
return REQ_PROCEED;
}
/* Fstat with parsedname already done */
ZERO_OR_ERROR FS_fstat_postparse(struct stat *stbuf, const struct parsedname *pn)
{
memset(stbuf, 0, sizeof(struct stat));
LEVEL_CALL("ATTRIBUTES path=%s", SAFESTRING(pn->path));
if (KnownBus(pn) && pn->known_bus == NULL) {
/* check for presence of first in-device at least since FS_ParsedName
* doesn't do it yet. */
return -ENOENT;
} else if (pn->selected_device == NO_DEVICE) { /* root directory */
int nr = 0;
//printf("FS_fstat root\n");
stbuf->st_mode = S_IFDIR | 0755;
stbuf->st_nlink = 2; // plus number of sub-directories
nr = -1; // make it 1
/*
If calculating NSUB is hard, the filesystem can set st_nlink of
directories to 1, and find will still work. This is not documented
behavior of find, and it's not clear whether this is intended or just
by accident. But for example the NTFS filesysem relies on this, so
it's unlikely that this "feature" will go away.
*/
stbuf->st_nlink += nr;
FSTATLOCK;
stbuf->st_atime = stbuf->st_ctime = stbuf->st_mtime = StateInfo.start_time;
FSTATUNLOCK;
stbuf->st_size = 4096 ; // Common directory size
return 0;
} else if (pn->selected_filetype == NO_FILETYPE) {
int nr = 0;
//printf("FS_fstat pn.selected_filetype == NULL (1-wire device)\n");
stbuf->st_mode = S_IFDIR | 0777;
stbuf->st_nlink = 2; // plus number of sub-directories
nr = -1; // make it 1
//printf("FS_fstat seem to be %d entries (%d dirs) in device\n", pn.selected_device->nft, nr);
stbuf->st_nlink += nr;
FSTATLOCK;
stbuf->st_atime = stbuf->st_ctime = stbuf->st_mtime = StateInfo.dir_time;
FSTATUNLOCK;
stbuf->st_size = 4096 ; // Common directory size
return 0;
} else if (pn->selected_filetype->format == ft_directory || pn->selected_filetype->format == ft_subdir) { /* other directory */
int nr = 0;
stbuf->st_mode = S_IFDIR | 0777;
stbuf->st_nlink = 2; // plus number of sub-directories
nr = -1; // make it 1
stbuf->st_nlink += nr;
FSTATLOCK;
stbuf->st_atime = stbuf->st_ctime = stbuf->st_mtime = StateInfo.dir_time;
FSTATUNLOCK;
stbuf->st_size = 4096 ; // Common directory size
return 0;
} else { /* known 1-wire filetype */
stbuf->st_mode = S_IFREG;
if (pn->selected_filetype->read != NO_READ_FUNCTION) {
stbuf->st_mode |= 0444;
}
if (!Globals.readonly && (pn->selected_filetype->write != NO_WRITE_FUNCTION)) {
stbuf->st_mode |= 0222;
}
stbuf->st_nlink = 1;
switch (pn->selected_filetype->change) {
case fc_volatile:
case fc_second:
case fc_statistic:
stbuf->st_atime = stbuf->st_ctime = stbuf->st_mtime = NOW_TIME;
break;
case fc_stable:
FSTATLOCK;
stbuf->st_atime = stbuf->st_ctime = stbuf->st_mtime = StateInfo.dir_time;
FSTATUNLOCK;
break;
default:
stbuf->st_atime = stbuf->st_ctime = stbuf->st_mtime = StateInfo.start_time;
break;
}
stbuf->st_size = FullFileLength(pn);
return 0;
}
}
/* special check, -remote file length won't match local sizes */
static ZERO_OR_ERROR FS_port(struct one_wire_query *owq)
{
return OWQ_format_output_offset_and_size_z(
SAFESTRING( DEVICENAME(PN(owq)->selected_connection)),
owq);
}
static GOOD_OR_BAD K1WM_reconnect(const struct parsedname * pn)
{
LEVEL_DEBUG("Attempting reconnect on %s",SAFESTRING(DEVICENAME(pn->selected_connection)));
return K1WM_setup(pn->selected_connection) ;
}
