/* remove an existing dos drive, by letter or udi */
NTSTATUS remove_dos_device( int letter, const char *udi )
{
HKEY hkey;
struct dos_drive *drive;
LIST_FOR_EACH_ENTRY( drive, &drives_list, struct dos_drive, entry )
{
if (letter != -1 && drive->drive != letter) continue;
if (udi)
{
if (!drive->udi) continue;
if (strcmp( udi, drive->udi )) continue;
}
if (drive->drive != -1)
{
BOOL modified = set_unix_mount_point( drive, NULL );
/* clear the registry key too */
if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, drives_keyW, &hkey ))
{
WCHAR name[3] = {'a',':',0};
name[0] += drive->drive;
RegDeleteValueW( hkey, name );
RegCloseKey( hkey );
}
if (modified && udi) send_notify( drive->drive, DBT_DEVICEREMOVECOMPLETE );
}
delete_disk_device( drive );
return STATUS_SUCCESS;
}
return STATUS_NO_SUCH_DEVICE;
}
int process_stab_reply(Header *header, ChordPacketArgs *args,
StabilizeReply *msg, Node *from)
{
ChordServer *srv = args->srv;
Finger *succ;
int fnew;
chordID id;
if (IN6_IS_ADDR_UNSPECIFIED(&srv->node.addr))
return CHORD_ADDR_UNDISCOVERED;
in6_addr addr;
memcpy(addr.s6_addr, msg->addr.data, 16);
get_address_id(&id, &addr, msg->port);
LOG_PROCESS(&id, NULL, -1);
// If we are our successor's predecessor, everything is fine, so do nothing.
if (v6_addr_equals(&srv->node.addr, &addr) && srv->node.port == msg->port)
return CHORD_NO_ERROR;
// Otherwise, there is a better successor in between us and our current
// successor. So we notify the in-between node that we should be its
// predecessor.
insert_finger(srv, &id, &addr, msg->port, &fnew);
succ = succ_finger(srv);
send_notify(srv, &succ->node.addr, succ->node.port);
if (fnew)
send_ping(srv, &addr, msg->port, get_current_time());
return CHORD_NO_ERROR;
}
int alert_push(int event, const char *msg)
{
/* 日志以及调试功能回调入口 */
switch(event){
case ERR_BASE:
case ERR_VERIFY:
case ERR_BRIDGE:
case ERR_PORT:
case ERR_CTRL_BRIDGE:
case ERR_CTRL_PORT:
ERROR2(GLOBAL_OUT_GROUP,"%s\n", msg);
break;
case ERR_MSTI:
ERROR2(MSTI_GROUP,"%s\n", msg);
break;
case ALERT_BASE:
case ALERT_BRIDGE:
case ALERT_PORT:
break;
case INFO_BRIDGE_TXBPDU:
case INFO_PORT_TXBPDU:
INFO2(BPDU_TX_GROUP,"%s\n", msg);
break;
case DEBUG_TXBPDU:
INFO3(BPDU_TX_GROUP,"%s\n", msg);
break;
case INFO_BRIDGE_RXBPDU:
case INFO_PORT_RXBPDU:
INFO2(BPDU_RX_GROUP,"%s\n", msg);
break;
case DEBUG_RXBPDU:
INFO3(BPDU_RX_GROUP,"%s\n", msg);
break;
case INFO_MSTI:
INFO2(MSTI_GROUP,"%s\n", msg);
break;
case INFO_BASE:
case INFO_BRIDGE:
case INFO_PORT:
case INFO_CTRL_BRIDGE:
case INFO_CTRL_PORT:
case INFO_CTRL_BRIDGE_MAC:
INFO2(GLOBAL_OUT_GROUP,"%s\n", msg);
break;
case DEBUG_INFO:
break;
case NOTIFY_MSG:
send_notify(event, msg);
break;
default:
break;
};
return 0;
}
/// Expire any old bindings, and calculates the latest outstanding expiry time,
/// or now if none.
///
/// @returns The latest expiry time from all unexpired bindings.
/// @param aor_data The registration data record.
/// @param now The current time in seconds since the epoch.
int RegStore::expire_bindings(AoR* aor_data,
int now,
SAS::TrailId trail)
{
int max_expires = now;
for (AoR::Bindings::iterator i = aor_data->_bindings.begin();
i != aor_data->_bindings.end();
)
{
AoR::Binding* b = i->second;
std::string b_id = i->first;
if (b->_expires <= now)
{
// Update the cseq
aor_data->_notify_cseq++;
// The binding has expired, so remove it. Send a SIP NOTIFY for this binding
// if there are any subscriptions
for (AoR::Subscriptions::iterator j = aor_data->_subscriptions.begin();
j != aor_data->_subscriptions.end();
++j)
{
// Don't send a notification when an emergency registration expires
if (!b->_emergency_registration)
{
send_notify(j->second, aor_data->_notify_cseq, b, b_id, trail);
}
}
// If a timer id is present, then delete it. If the timer id is empty (because a
// previous post/put failed) then don't.
if (b->_timer_id != "")
{
_chronos->send_delete(b->_timer_id, trail);
}
delete i->second;
aor_data->_bindings.erase(i++);
}
else
{
if (b->_expires > max_expires)
{
max_expires = b->_expires;
}
++i;
}
}
return max_expires;
}
/* send notifies for any updated areas */
static void
notify_areas(Area *a, Request *req)
{
Server *s;
for(; a != nil; a = a->next){
if(!a->neednotify)
continue;
/* send notifies to all slaves */
for(s = a->soarr->soa->slaves; s != nil; s = s->next)
send_notify(s->name, a->soarr, req);
a->neednotify = 0;
}
}
static void mwi_stasis_cb(void *userdata, struct stasis_subscription *sub,
struct stasis_message *msg)
{
struct mwi_subscription *mwi_sub = userdata;
if (stasis_subscription_final_message(sub, msg)) {
if (ast_sip_push_task(NULL, serialized_cleanup, ao2_bump(mwi_sub))) {
ao2_ref(mwi_sub, -1);
}
return;
}
if (ast_mwi_state_type() == stasis_message_type(msg)) {
send_notify(mwi_sub, NULL, 0);
}
}
// Get and send a fortune.
void send_fortune ()
{
std::string fortune;
try
{
fortune = get_fortune ();
}
catch (int e)
{
display_error_dialog ("Could not get output of 'fortune'.\n"
"Please verify you have it installed in your system.");
return;
}
send_notify (fortune, settings.getTimeout ());
}
static void add_dos_device( const char *udi, const char *device,
const char *mount_point, const char *type )
{
struct dos_drive *drive;
/* first check if it already exists */
LIST_FOR_EACH_ENTRY( drive, &drives_list, struct dos_drive, entry )
{
if (!strcmp( udi, drive->udi )) goto found;
}
if (!(drive = HeapAlloc( GetProcessHeap(), 0, sizeof(*drive) ))) return;
if (!(drive->udi = HeapAlloc( GetProcessHeap(), 0, strlen(udi)+1 )))
{
HeapFree( GetProcessHeap(), 0, drive );
return;
}
strcpy( drive->udi, udi );
list_add_tail( &drives_list, &drive->entry );
found:
drive->drive = add_drive( device, type );
if (drive->drive != -1)
{
HKEY hkey;
set_mount_point( drive, mount_point );
WINE_TRACE( "added device %c: udi %s for %s on %s type %s\n",
'a' + drive->drive, wine_dbgstr_a(udi), wine_dbgstr_a(device),
wine_dbgstr_a(mount_point), wine_dbgstr_a(type) );
/* hack: force the drive type in the registry */
if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Drives", &hkey ))
{
char name[3] = "a:";
name[0] += drive->drive;
if (!type || strcmp( type, "cdrom" )) type = "floppy"; /* FIXME: default to floppy */
RegSetValueExA( hkey, name, 0, REG_SZ, (const BYTE *)type, strlen(type) + 1 );
RegCloseKey( hkey );
}
send_notify( drive->drive, DBT_DEVICEARRIVAL );
}
}
static int do_recv(struct libxenvchan *ctrl, void *data, size_t size)
{
int real_idx = rd_cons(ctrl) & (rd_ring_size(ctrl) - 1);
int avail_contig = rd_ring_size(ctrl) - real_idx;
if (avail_contig > size)
avail_contig = size;
xen_rmb(); /* data read must happen /after/ rd_cons read */
memcpy(data, rd_ring(ctrl) + real_idx, avail_contig);
if (avail_contig < size)
{
// we rolled across the end of the ring
memcpy(data + avail_contig, rd_ring(ctrl), size - avail_contig);
}
xen_mb(); /* consume /then/ notify */
rd_cons(ctrl) += size;
if (send_notify(ctrl, VCHAN_NOTIFY_READ))
return -1;
return size;
}
/**
* returns -1 on error, or size on success
*/
static int do_send(struct libxenvchan *ctrl, const void *data, size_t size)
{
int real_idx = wr_prod(ctrl) & (wr_ring_size(ctrl) - 1);
int avail_contig = wr_ring_size(ctrl) - real_idx;
if (avail_contig > size)
avail_contig = size;
xen_mb(); /* read indexes /then/ write data */
memcpy(wr_ring(ctrl) + real_idx, data, avail_contig);
if (avail_contig < size)
{
// we rolled across the end of the ring
memcpy(wr_ring(ctrl), data + avail_contig, size - avail_contig);
}
xen_wmb(); /* write data /then/ notify */
wr_prod(ctrl) += size;
if (send_notify(ctrl, VCHAN_NOTIFY_WRITE))
return -1;
return size;
}
static void remove_dos_device( struct dos_drive *drive )
{
HKEY hkey;
if (drive->drive != -1)
{
set_mount_point( drive, "" );
/* clear the registry key too */
if (!RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Drives", &hkey ))
{
char name[3] = "a:";
name[0] += drive->drive;
RegDeleteValueA( hkey, name );
RegCloseKey( hkey );
}
send_notify( drive->drive, DBT_DEVICEREMOVECOMPLETE );
}
list_remove( &drive->entry );
HeapFree( GetProcessHeap(), 0, drive->udi );
HeapFree( GetProcessHeap(), 0, drive );
}
static void send_notifies(db1_res_t *result, int did_col, int resource_uri_col, int auth_state_col, int reason_col,
int pres_state_col, int content_type_col)
{
int i;
char* prev_did= NULL, * curr_did= NULL;
db_row_t *row;
db_val_t *row_vals;
char* resource_uri;
str pres_state = {0, 0};
xmlDocPtr rlmi_doc= NULL;
xmlNodePtr list_node= NULL, instance_node= NULL, resource_node;
unsigned int hash_code= 0;
int size= BUF_REALLOC_SIZE, buf_len= 0;
char* buf= NULL, *auth_state= NULL, *boundary_string= NULL;
str cid = {0,0};
str content_type= {0, 0};
int auth_state_flag;
int chunk_len=0;
str bstr= {0, 0};
subs_t* dialog= NULL;
int len_est = 0;
int resource_added = 0; /* Flag to indicate that we have added at least one resource */
/* generate the boundary string */
boundary_string= generate_string(BOUNDARY_STRING_LEN);
bstr.len= strlen(boundary_string);
bstr.s= (char*)pkg_malloc((bstr.len+ 1)* sizeof(char));
if(bstr.s== NULL)
{
ERR_MEM(PKG_MEM_STR);
}
memcpy(bstr.s, boundary_string, bstr.len);
bstr.s[bstr.len]= '\0';
/* Allocate an initial buffer for the multipart body.
* This buffer will be reallocated if neccessary */
buf= pkg_malloc(size* sizeof(char));
if(buf== NULL)
{
ERR_MEM(PKG_MEM_STR);
}
LM_DBG("found %d records with updated state\n", result->n);
for(i= 0; i< result->n; i++)
{
row = &result->rows[i];
row_vals = ROW_VALUES(row);
curr_did= (char*)row_vals[did_col].val.string_val;
resource_uri= (char*)row_vals[resource_uri_col].val.string_val;
auth_state_flag= row_vals[auth_state_col].val.int_val;
pres_state.s= (char*)row_vals[pres_state_col].val.string_val;
pres_state.len = strlen(pres_state.s);
trim(&pres_state);
/* If we have moved onto a new resource list Subscribe dialog indentifier,
send a NOTIFY for the previous ID and then drop the existing documents. */
if(prev_did!= NULL && strcmp(prev_did, curr_did))
{
if (send_notify(&rlmi_doc, buf, buf_len, bstr, dialog, hash_code))
{
LM_ERR("in send_notify\n");
goto error;
}
len_est = 0;
pkg_free(dialog);
dialog= NULL;
}
/*if first or different*/
if(prev_did==NULL || strcmp(prev_did, curr_did)!=0)
{
/* Work out a subscription from the did. */
get_dialog_from_did(curr_did, &dialog, &hash_code);
if(dialog== NULL)
{
prev_did = NULL;
LM_INFO("Dialog is NULL\n");
continue;
}
len_est = create_empty_rlmi_doc(&rlmi_doc, &list_node, &dialog->pres_uri, dialog->version, 0);
len_est += 2*strlen(boundary_string)+4+102+2+50+strlen(resource_uri)+20;
buf_len= 0;
resource_added = 0;
/* !!!! for now I will include the auth state without checking if
* it has changed - > in future chech if it works */
}
/* add a node in rlmi_doc and if any presence state registered add
* it in the buffer */
resource_node= xmlNewChild(list_node,NULL,BAD_CAST "resource", NULL);
if(resource_node== NULL)
{
LM_ERR("when adding resource child\n");
goto done;
}
xmlNewProp(resource_node, BAD_CAST "uri", BAD_CAST resource_uri);
len_est += strlen (resource_uri) + 35; /* <resource uri="[uri]"></resource>/r/n */
resource_added = 1;
/* there might be more records with the same uri- more instances-
* search and add them all */
while(1)
{
cid.s= NULL;
cid.len= 0;
auth_state= get_auth_string(auth_state_flag);
if(auth_state== NULL)
{
LM_ERR("bad authorization status flag\n");
goto error;
}
len_est += strlen(auth_state) + 38; /* <instance id="12345678" state="[auth_state]" />r/n */
if(auth_state_flag & ACTIVE_STATE)
{
cid.s= generate_cid(resource_uri, strlen(resource_uri));
cid.len = strlen(cid.s);
len_est += cid.len + 8; /* cid="[cid]" */
content_type.s = (char*)row_vals[content_type_col].val.string_val;
content_type.len = strlen(content_type.s);
chunk_len = 4 + bstr.len
+ 35
+ 16 + cid.len
+ 18 + content_type.len
+ 4 + pres_state.len + 8;
len_est += chunk_len;
}
else
if(auth_state_flag & TERMINATED_STATE)
{
len_est += strlen(row_vals[resource_uri_col].val.string_val) + 10; /* reason="[resaon]" */
}
if (rls_max_notify_body_len > 0 && len_est > rls_max_notify_body_len)
{
/* We have a limit on body length set, and we were about to exceed it */
if (resource_added == 1)
{
/* We added at least one resource. */
LM_DBG("timer_send_notify hit the size limit. len_est = %d\n", len_est);
if (send_notify(&rlmi_doc, buf, buf_len, bstr, dialog, hash_code))
{
LM_ERR("in send_notify\n");
goto error;
}
i --;
}
else
{
LM_DBG("timer_send_notify hit the size limit. NO RESOURCE ADDED len_est = %d\n", len_est);
}
len_est = 0;
pkg_free(dialog);
dialog= NULL;
curr_did=NULL;
break;
}
/* OK, we are happy this will fit */
instance_node= xmlNewChild(resource_node, NULL, BAD_CAST "instance", NULL);
if(instance_node== NULL)
{
LM_ERR("while adding instance child\n");
goto error;
}
/* Instance ID should be unique for each instance node
within a resource node. The same instance ID can be
used in different resource nodes. Instance ID needs
to remain the same for each resource instance in
future updates. We can just use a common string
here because you will only get multiple instances
for a resource when the back-end SUBSCRIBE is forked
and pua does not support this. If/when pua supports
forking of the SUBSCRIBEs it sends this will need to
be fixed properly. */
xmlNewProp(instance_node, BAD_CAST "id",
BAD_CAST instance_id);
if(auth_state_flag & ACTIVE_STATE)
{
xmlNewProp(instance_node, BAD_CAST "state", BAD_CAST auth_state);
}
else
if(auth_state_flag & TERMINATED_STATE)
{
xmlNewProp(instance_node, BAD_CAST "reason",
BAD_CAST row_vals[resource_uri_col].val.string_val);
}
xmlNewProp(instance_node, BAD_CAST "cid", BAD_CAST cid.s);
/* add in the multipart buffer */
if(cid.s)
{
while(buf_len + chunk_len >= size)
{
REALLOC_BUF
}
buf_len+= sprintf(buf+ buf_len, "--%.*s\r\n", bstr.len,
bstr.s);
buf_len+= sprintf(buf+ buf_len,
"Content-Transfer-Encoding: binary\r\n");
buf_len+= sprintf(buf+ buf_len, "Content-ID: <%.*s>\r\n",
cid.len, cid.s);
buf_len+= sprintf(buf+ buf_len, "Content-Type: %.*s\r\n\r\n",
content_type.len, content_type.s);
buf_len+= sprintf(buf+buf_len,"%.*s\r\n\r\n", pres_state.len,
pres_state.s);
}
i++;
if(i== result->n)
{
i--;
break;
}
row = &result->rows[i];
row_vals = ROW_VALUES(row);
if(strncmp(resource_uri, row_vals[resource_uri_col].val.string_val,
strlen(resource_uri))
|| strncmp(curr_did, row_vals[did_col].val.string_val,
strlen(curr_did)))
{
i--;
break;
}
resource_uri= (char*)row_vals[resource_uri_col].val.string_val;
auth_state_flag= row_vals[auth_state_col].val.int_val;
pres_state.s= (char*)row_vals[pres_state_col].val.string_val;
pres_state.len= strlen(pres_state.s);
trim(&pres_state);
}
prev_did= curr_did;
}
if(rlmi_doc)
{
LM_DBG("timer_send_notify at end len_est = %d resource_added = %d\n", len_est, resource_added);
if (resource_added == 1)
{
send_notify(&rlmi_doc, buf, buf_len, bstr, dialog, hash_code);
}
if(dialog)
{
pkg_free(dialog);
}
dialog= NULL;
}
error:
done:
if(bstr.s)
pkg_free(bstr.s);
if(buf)
pkg_free(buf);
if(dialog)
pkg_free(dialog);
return;
}
static int alert_push(int event, const char *msg)
{
send_notify(event, msg);
return 0;
}
/* create a new dos drive */
NTSTATUS add_dos_device( int letter, const char *udi, const char *device,
const char *mount_point, enum device_type type )
{
struct dos_drive *drive, *next;
if (letter == -1) /* auto-assign a letter */
{
letter = add_drive( device, type );
if (letter == -1) return STATUS_OBJECT_NAME_COLLISION;
}
else /* simply reset the device symlink */
{
char *path, *p;
if (!(path = get_dosdevices_path( &p ))) return STATUS_NO_MEMORY;
*p = 'a' + letter;
unlink( path );
if (device) symlink( device, path );
}
LIST_FOR_EACH_ENTRY_SAFE( drive, next, &drives_list, struct dos_drive, entry )
{
if (udi && drive->udi && !strcmp( udi, drive->udi ))
{
if (type == drive->type) goto found;
delete_disk_device( drive );
continue;
}
if (drive->drive == letter) delete_disk_device( drive );
}
if (create_disk_device( udi, type, &drive )) return STATUS_NO_MEMORY;
found:
RtlFreeHeap( GetProcessHeap(), 0, drive->unix_device );
drive->unix_device = strdupA( device );
set_drive_letter( drive, letter );
set_unix_mount_point( drive, mount_point );
if (drive->drive != -1)
{
HKEY hkey;
TRACE( "added device %c: udi %s for %s on %s type %u\n",
'a' + drive->drive, wine_dbgstr_a(udi), wine_dbgstr_a(device),
wine_dbgstr_a(mount_point), type );
/* hack: force the drive type in the registry */
if (!RegCreateKeyW( HKEY_LOCAL_MACHINE, drives_keyW, &hkey ))
{
const WCHAR *type_name = drive_types[type];
WCHAR name[3] = {'a',':',0};
name[0] += drive->drive;
if (!type_name[0] && type == DEVICE_HARDDISK) type_name = drive_types[DEVICE_FLOPPY];
if (type_name[0])
RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)type_name,
(strlenW(type_name) + 1) * sizeof(WCHAR) );
else
RegDeleteValueW( hkey, name );
RegCloseKey( hkey );
}
if (udi) send_notify( drive->drive, DBT_DEVICEARRIVAL );
}
return STATUS_SUCCESS;
}
BaseError AppManMsgProxy::linkDownNotification()
{
return send_notify(SC_AM_LINK_DOWN_NOTIFY);
}
BaseError AppManMsgProxy::linkUpNotification()
{
return send_notify(SC_AM_LINK_UP_NOTIFY);
}
