LDLUA_METHOD meta_add_uint(lua_State* L)
{
int32_t status;
#define LDLUA_OPTARG_META_TYPE 2
#define LDLUA_OPTARG_NUM 3
meta ss = check_meta(L, 1);
uint16_t type = (uint16_t)luaL_optlong(L, LDLUA_OPTARG_META_TYPE, 0);
uint32_t num = (uint32_t)luaL_optlong(L, LDLUA_OPTARG_NUM, 0);
status = meta_buffer_item_add(ss, type, &num, sizeof(uint32_t));
if (status != 0) {
luaL_error(L,"savestr error, status %d\n", status);
}
return 0;
}
inline int socket_addState( lua_State *L )
{
D_SOCKET *socket;
SOCKET_STATE *state;
DAVLUACM_SOCKET_NIL( socket, L );
if( ( state = (SOCKET_STATE *)check_meta( L, 2, "State.meta" ) ) == NULL )
{
bug( "%s: cannot add non-State.meta to socket states.", __FUNCTION__ );
lua_pushnil( L );
return 1;
}
AttachToList( socket->states );
lua_pushnumber( L, SizeOfList( socket->states ) );
return 1;
}
LDLUA_METHOD meta_add_ff(lua_State* L)
{
int32_t status;
meta_ff_t ff;
#define LDLUA_OPTARG_IP 2
#define LDLUA_OPTARG_PORT 3
#define LDLUA_OPTARG_APP_TYPE 4
meta ss = check_meta(L, 1);
ff.ip = (uint32_t)luaL_optlong(L, LDLUA_OPTARG_IP, 0);
ff.port = (uint16_t)luaL_optlong(L, LDLUA_OPTARG_PORT, 0);
ff.app_type = (uint32_t)luaL_optlong(L, LDLUA_OPTARG_APP_TYPE, 0);
status = meta_buffer_item_add(ss, META_TYPE_FF, &ff, sizeof(ff));
if (status != 0) {
luaL_error(L,"savestr error, status %d\n", status);
}
return 0;
}
int main(int argc, char *argv[])
{
char *prop_file = NULL;
if ( get_options( argc, argv) ) {
return -1;
}
prop_file = getenv("ZS_PROPERTY_FILE");
if (prop_file) {
ZSLoadProperties(prop_file);
}
if( label == 1 ) {
ZSSetProperty("ZS_FAULT_LABEL_CORRUPTION","1");
}
if( superblock == 1 ) {
ZSSetProperty("ZS_FAULT_SBLOCK_CORRUPTION","1");
}
if( shard_prop == 1 ) {
ZSSetProperty("ZS_FAULT_SHARD_PROP_CORRUPTION","1");
}
if( shard_desc == 1 ) {
ZSSetProperty("ZS_FAULT_SHARD_DESC_CORRUPTION","1");
}
if( seg_list == 1 ) {
ZSSetProperty("ZS_FAULT_SEGLIST_CORRUPTION","1");
}
if( class_desc == 1 ) {
ZSSetProperty("ZS_FAULT_CLASS_DESC_CORRUPTION","1");
}
if( chkpoint == 1 ) {
ZSSetProperty("ZS_FAULT_CHKPOINT_CORRUPTION","1");
}
if( flog == 1 ) {
ZSSetProperty("ZS_FAULT_FLOG_CORRUPTION","1");
}
if( pot == 1 ) {
ZSSetProperty("ZS_FAULT_POT_CORRUPTION","1");
}
if( potbitmap == 1 ) {
ZSSetProperty("ZS_FAULT_POTBITMAP_CORRUPTION","1");
}
if( slabbitmap == 1 ) {
ZSSetProperty("ZS_FAULT_SLABBITMAP_CORRUPTION","1");
}
if( container == 0 ) {
ZSSetProperty("ZS_FAULT_CONTAINER_CMC","1");
}
if( container == 1 ) {
ZSSetProperty("ZS_FAULT_CONTAINER_VMC","1");
}
if( container == 2 ) {
ZSSetProperty("ZS_FAULT_CONTAINER_VDC","1");
}
if( container == -1 ) {
ZSSetProperty("ZS_FAULT_CONTAINER_CMC","1");
ZSSetProperty("ZS_FAULT_CONTAINER_VMC","1");
ZSSetProperty("ZS_FAULT_CONTAINER_VDC","1");
}
if( container == -255 ) {
fprintf(stderr,"\nUsage error: Container ID not specified\n");
print_usage(argv[0]);
exit(1);
}
if( flog == 1 ) {
if( atoi(ZSGetProperty("ZS_FAULT_CONTAINER_CMC", "0")) == 1 ) {
flog_corrupt(CMC_SHARD_ID);
}
if( atoi(ZSGetProperty("ZS_FAULT_CONTAINER_VMC", "0")) == 1 ) {
flog_corrupt(VMC_SHARD_ID);
}
if( atoi(ZSGetProperty("ZS_FAULT_CONTAINER_VDC", "0")) == 1 ) {
flog_corrupt(VDC_SHARD_ID);
}
}
unsetenv("ZS_PROPERTY_FILE");
ZSSetProperty("ZS_META_FAULT_INJECTION", "1");
ZSSetProperty("ZS_REFORMAT", "0");
if ((potbitmap == 1 || slabbitmap == 1) && !atoi(ZSGetProperty("ZS_STORM_MODE", "1"))) {
fprintf(stderr, "POT/SLAB bitmap check only allowed in Storm mode\n");
print_usage(argv[0]);
return -1;
}
ZSCheckInit(logfile);
if (ZS_SUCCESS != check_meta()) {
fprintf(stderr, "meta check failed, unable to continue\n");
return -1;
} else {
fprintf(stderr, "meta corruption succeeded\n");
}
if (0) {
if( pot != 1 ) {
exit(0);
}
if( (label == 1) || (superblock ==1 ) || (shard_prop == 1) || (shard_desc == 1) ||
(seg_list == 1) || ( class_desc == 1 ) || ( class_desc == 1 ) || (chkpoint == 1 ) ||
(flog == 1 ) || (potbitmap == 1) || (slabbitmap == 1) ) {
fprintf(stderr, "POT corruption can not be done when one of the following option is enabled\n"
"label,superblock,shard_prop,shard_desc,seg_list,class_desc,chkpoint\n");
exit(0);
}
}
return 0;
}
void
scan_itunes_itml(const char *file, time_t mtime, int dir_id)
{
struct playlist_info *pli;
struct stat sb;
char buf[PATH_MAX];
char *itml_xml;
plist_t itml;
plist_t node;
int fd;
int ret;
// This is special playlist that is disabled and only used for saving a timestamp
pli = db_pl_fetch_bytitlepath(file, file);
if (pli)
{
// mtime == db_timestamp is also treated as a modification because some editors do
// stuff like 1) close the file with no changes (leading us to update db_timestamp),
// 2) copy over a modified version from a tmp file (which may result in a mtime that
// is equal to the newly updated db_timestamp)
if (mtime && (pli->db_timestamp > mtime))
{
DPRINTF(E_LOG, L_SCAN, "Unchanged iTunes XML found, not processing '%s'\n", file);
// TODO Protect the radio stations from purge after scan
db_pl_ping_bymatch(file, 0);
free_pli(pli, 0);
return;
}
DPRINTF(E_LOG, L_SCAN, "Modified iTunes XML found, processing '%s'\n", file);
// Clear out everything, we will recreate
db_pl_delete_bypath(file);
free_pli(pli, 0);
}
else
{
DPRINTF(E_LOG, L_SCAN, "New iTunes XML found, processing: '%s'\n", file);
}
CHECK_NULL(L_SCAN, pli = calloc(1, sizeof(struct playlist_info)));
pli->type = PL_PLAIN;
pli->title = strdup(file);
pli->path = strdup(file);
snprintf(buf, sizeof(buf), "/file:%s", file);
pli->virtual_path = strip_extension(buf);
pli->directory_id = dir_id;
ret = db_pl_add(pli, (int *)&pli->id);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Error adding iTunes XML meta playlist '%s'\n", file);
free_pli(pli, 0);
return;
}
// Disable, only used for saving timestamp
db_pl_disable_bypath(file, STRIP_NONE, 0);
free_pli(pli, 0);
fd = open(file, O_RDONLY);
if (fd < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not open iTunes library '%s': %s\n", file, strerror(errno));
return;
}
ret = fstat(fd, &sb);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not stat iTunes library '%s': %s\n", file, strerror(errno));
close(fd);
return;
}
itml_xml = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (itml_xml == MAP_FAILED)
{
DPRINTF(E_LOG, L_SCAN, "Could not map iTunes library '%s': %s\n", file, strerror(errno));
close(fd);
return;
}
itml = NULL;
plist_from_xml(itml_xml, sb.st_size, &itml);
ret = munmap(itml_xml, sb.st_size);
if (ret < 0)
DPRINTF(E_LOG, L_SCAN, "Could not unmap iTunes library '%s': %s\n", file, strerror(errno));
close(fd);
if (!itml)
{
DPRINTF(E_LOG, L_SCAN, "iTunes XML playlist '%s' failed to parse\n", file);
return;
}
if (plist_get_node_type(itml) != PLIST_DICT)
{
DPRINTF(E_LOG, L_SCAN, "Malformed iTunes XML playlist '%s'\n", file);
plist_free(itml);
return;
}
/* Meta data */
ret = check_meta(itml);
if (ret < 0)
{
plist_free(itml);
return;
}
/* Tracks */
ret = get_dictval_dict_from_key(itml, "Tracks", &node);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not find Tracks dict in '%s'\n", file);
plist_free(itml);
return;
}
id_map = calloc(ID_MAP_SIZE, sizeof(struct itml_to_db_map *));
if (!id_map)
{
DPRINTF(E_FATAL, L_SCAN, "iTunes library parser could not allocate ID map\n");
plist_free(itml);
return;
}
ret = process_tracks(node);
if (ret <= 0)
{
DPRINTF(E_LOG, L_SCAN, "No tracks loaded from iTunes XML '%s'\n", file);
id_map_free();
plist_free(itml);
return;
}
DPRINTF(E_LOG, L_SCAN, "Loaded %d tracks from iTunes XML '%s'\n", ret, file);
/* Playlists */
ret = get_dictval_array_from_key(itml, "Playlists", &node);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not find Playlists dict in '%s'\n", file);
id_map_free();
plist_free(itml);
return;
}
process_pls(node, file);
id_map_free();
plist_free(itml);
}
void
scan_itunes_itml(char *file)
{
struct stat sb;
char *itml_xml;
char *ptr;
plist_t itml;
plist_t node;
int fd;
int size;
int ret;
DPRINTF(E_LOG, L_SCAN, "Processing iTunes library: %s\n", file);
fd = open(file, O_RDONLY);
if (fd < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not open iTunes library '%s': %s\n", file, strerror(errno));
return;
}
ret = fstat(fd, &sb);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not stat iTunes library '%s': %s\n", file, strerror(errno));
close(fd);
return;
}
itml_xml = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (itml_xml == MAP_FAILED)
{
DPRINTF(E_LOG, L_SCAN, "Could not map iTunes library: %s\n", strerror(errno));
close(fd);
return;
}
itml = NULL;
plist_from_xml(itml_xml, sb.st_size, &itml);
ret = munmap(itml_xml, sb.st_size);
if (ret < 0)
DPRINTF(E_LOG, L_SCAN, "Could not unmap iTunes library: %s\n", strerror(errno));
close(fd);
if (!itml)
{
DPRINTF(E_LOG, L_SCAN, "iTunes XML playlist '%s' failed to parse\n", file);
return;
}
if (plist_get_node_type(itml) != PLIST_DICT)
{
DPRINTF(E_LOG, L_SCAN, "Malformed iTunes XML playlist '%s'\n", file);
plist_free(itml);
return;
}
/* Meta data */
ret = check_meta(itml);
if (ret < 0)
{
plist_free(itml);
return;
}
/* Tracks */
ret = get_dictval_dict_from_key(itml, "Tracks", &node);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not find Tracks dict\n");
plist_free(itml);
return;
}
size = ID_MAP_SIZE * sizeof(struct itml_to_db_map *);
id_map = malloc(size);
if (!id_map)
{
DPRINTF(E_FATAL, L_SCAN, "iTunes library parser could not allocate ID map\n");
plist_free(itml);
return;
}
memset(id_map, 0, size);
ptr = strrchr(file, '/');
if (!ptr)
{
DPRINTF(E_FATAL, L_SCAN, "Invalid filename\n");
id_map_free();
plist_free(itml);
return;
}
*ptr = '\0';
ret = process_tracks(node);
if (ret <= 0)
{
DPRINTF(E_LOG, L_SCAN, "No tracks loaded\n");
id_map_free();
plist_free(itml);
return;
}
*ptr = '/';
DPRINTF(E_INFO, L_SCAN, "Loaded %d tracks from iTunes library\n", ret);
/* Playlists */
ret = get_dictval_array_from_key(itml, "Playlists", &node);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not find Playlists dict\n");
id_map_free();
plist_free(itml);
return;
}
process_pls(node, file);
id_map_free();
plist_free(itml);
}
bool wxKeyTextCtrl::ParseString(const wxChar* s, int len, int &mod, int &key)
{
mod = key = 0;
if (!s || !len)
return false;
wxString a = wxT('\t');
a.append(s, len);
wxAcceleratorEntry ae;
#ifndef __WXMAC__
#define check_meta(str) do { \
wxString meta = str; \
for(int ml = 0; (ml = a.find(meta, ml)) != wxString::npos; ml++) { \
if(!ml || a[ml-1] == wxT('-') || a[ml-1] == wxT('+')) { \
mod |= wxMOD_META; \
a.erase(ml, meta.size()); \
ml = -1; \
} \
} \
} while(0)
check_meta(wxT("Meta-"));
check_meta(wxT("Meta+"));
check_meta(_("Meta-"));
check_meta(_("Meta+"));
#endif
// wx disallows standalone modifiers
// unlike ToString(), this generates a debug message rather than
// an assertion error, so it's easy to ignore and expensive to avoid
// beforehand. Instead, check for them on failure
if (!ae.FromString(a))
{
a.MakeUpper();
#define chk_str(n, k) do { \
wxString t = n; \
if(a.size() > t.size() && a.substr(a.size() - t.size()) == t) { \
a.replace(a.size() - t.size(), t.size(), wxT("F1")); \
wxString ss(s); \
if(ae.FromString(a)) { \
mod |= ae.GetFlags(); \
key = k; \
return true; \
} \
a.replace(a.size() - 2, 2, n); \
} \
} while(0)
chk_str(wxT("ALT"), WXK_ALT);
chk_str(wxT("SHIFT"), WXK_SHIFT);
chk_str(wxT("CTRL"), WXK_CONTROL);
chk_str(wxT("CONTROL"), WXK_CONTROL);
chk_str(_("ALT"), WXK_ALT);
chk_str(_("SHIFT"), WXK_SHIFT);
chk_str(_("CTRL"), WXK_CONTROL);
chk_str(_("CONTROL"), WXK_CONTROL);
return false;
}
mod |= ae.GetFlags();
key = ae.GetKeyCode();
// wx makes key lower-case, but key events return upper case
if (key < WXK_START && wxIslower(key))
key = wxToupper(key);
return true;
}