/*----------------------------------------------------------------------
| PLT_MediaServer::ParseSort
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaServer::ParseSort(const NPT_String& sort, NPT_List<NPT_String>& list)
{
// reset output params first
list.Clear();
// easy out
if (sort.GetLength() == 0 || sort == "*") return NPT_SUCCESS;
list = sort.Split(",");
// verify each property has a namespace
NPT_List<NPT_String>::Iterator property = list.GetFirstItem();
while (property) {
NPT_List<NPT_String> parsed_property = (*property).Split(":");
if (parsed_property.GetItemCount() != 2)
parsed_property = (*property).Split("@");
if (parsed_property.GetItemCount() != 2 ||
(!(*property).StartsWith("-") && !(*property).StartsWith("+"))) {
NPT_LOG_WARNING_1("Invalid SortCriteria property %s", (*property).GetChars());
return NPT_FAILURE;
}
property++;
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_File::GetRoots
+---------------------------------------------------------------------*/
NPT_Result
NPT_File::GetRoots(NPT_List<NPT_String>& roots)
{
roots.Clear();
roots.Add("/");
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_NetworkNameResolver::Resolve
+---------------------------------------------------------------------*/
NPT_Result
NPT_NetworkNameResolver::Resolve(const char* name,
NPT_List<NPT_IpAddress>& addresses,
NPT_Timeout /*timeout*/)
{
// empty the list first
addresses.Clear();
// get the addr list
//struct addrinfo hints;
//NPT_SetMemory(&hints, 0, sizeof(hints));
//hints.ai_family = PF_UNSPEC;
//hints.ai_socktype = SOCK_STREAM;
//hints.ai_flags = AI_DEFAULT;
struct addrinfo *infos = NULL;
int result = getaddrinfo(name, /* hostname */
NULL, /* servname */
NULL, /* hints */
&infos /* res */);
if (result != 0) {
return MapGetAddrInfoErrorCode(result);
}
for (struct addrinfo* info = infos;
info && addresses.GetItemCount() < NPT_BSD_NETWORK_MAX_ADDR_LIST_LENGTH;
info = info->ai_next) {
unsigned int expected_length;
if (info->ai_family == AF_INET) {
expected_length = sizeof(struct sockaddr_in);
#if defined(NPT_CONFIG_ENABLE_IPV6)
} else if (info->ai_family == AF_INET6) {
expected_length = sizeof(struct sockaddr_in6);
#endif
} else {
continue;
}
if ((unsigned int)info->ai_addrlen < expected_length) continue;
if (info->ai_protocol != 0 && info->ai_protocol != IPPROTO_TCP) continue;
if (info->ai_family == AF_INET) {
struct sockaddr_in* inet_addr = (struct sockaddr_in*)info->ai_addr;
NPT_IpAddress address(ntohl(inet_addr->sin_addr.s_addr));
addresses.Add(address);
}
#if defined(NPT_CONFIG_ENABLE_IPV6)
else if (info->ai_family == AF_INET6) {
struct sockaddr_in6* inet_addr = (struct sockaddr_in6*)info->ai_addr;
NPT_IpAddress address(NPT_IpAddress::IPV6, inet_addr->sin6_addr.s6_addr, 16, inet_addr->sin6_scope_id);
addresses.Add(address);
}
#endif
}
freeaddrinfo(infos);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_File::ListDir
+---------------------------------------------------------------------*/
NPT_Result
NPT_File::ListDir(const char* path,
NPT_List<NPT_String>& entries,
NPT_Ordinal start /* = 0 */,
NPT_Cardinal max /* = 0 */)
{
// default return value
entries.Clear();
// check the arguments
if (path == NULL) return NPT_ERROR_INVALID_PARAMETERS;
// list the entries
DIR *directory = opendir(path);
if (directory == NULL) return NPT_ERROR_NO_SUCH_ITEM;
NPT_Cardinal count = 0;
for (;;) {
struct dirent* entry_pointer = NULL;
#if defined(NPT_CONFIG_HAVE_READDIR_R)
struct dirent entry;
int result = readdir_r(directory, &entry, &entry_pointer);
if (result != 0 || entry_pointer == NULL) break;
#else
entry_pointer = readdir(directory);
if (entry_pointer == NULL) break;
#endif
// ignore odd names
if (entry_pointer->d_name[0] == '\0') continue;
// ignore . and ..
if (entry_pointer->d_name[0] == '.' &&
entry_pointer->d_name[1] == '\0') {
continue;
}
if (entry_pointer->d_name[0] == '.' &&
entry_pointer->d_name[1] == '.' &&
entry_pointer->d_name[2] == '\0') {
continue;
}
// continue if we still have some items to skip
if (start > 0) {
--start;
continue;
}
entries.Add(NPT_String(entry_pointer->d_name));
// stop when we have reached the maximum requested
if (max && ++count == max) break;
}
closedir(directory);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_File::ListDir
+---------------------------------------------------------------------*/
NPT_Result
NPT_File::ListDir(const char* path,
NPT_List<NPT_String>& entries,
NPT_Ordinal start /* = 0 */,
NPT_Cardinal max /* = 0 */)
{
// default return value
entries.Clear();
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_File::ListDir
+---------------------------------------------------------------------*/
NPT_Result
NPT_File::ListDir(const char* path,
NPT_List<NPT_String>& entries,
NPT_Ordinal start /* = 0 */,
NPT_Cardinal max /* = 0 */)
{
NPT_WIN32_USE_CHAR_CONVERSION;
// default return value
entries.Clear();
// check the arguments
if (path == NULL || path[0] == '\0') return NPT_ERROR_INVALID_PARAMETERS;
// construct a path name with a \* wildcard at the end
NPT_String path_pattern = path;
if (path_pattern.EndsWith("\\") || path_pattern.EndsWith("/")) {
path_pattern += "*";
} else {
path_pattern += "\\*";
}
// list the entries
WIN32_FIND_DATAW find_data;
HANDLE find_handle = FindFirstFileW(NPT_WIN32_A2W(path_pattern.GetChars()), &find_data);
if (find_handle == INVALID_HANDLE_VALUE) return MapError(GetLastError());
NPT_Cardinal count = 0;
do {
if (NPT_File_ProcessFindData(&find_data)) {
// continue if we still have entries to skip
if (start > 0) {
--start;
continue;
}
entries.Add(NPT_WIN32_W2A(find_data.cFileName));
// stop when we have reached the maximum requested
if (max && ++count == max) return NPT_SUCCESS;
}
} while (FindNextFileW(find_handle, &find_data));
DWORD last_error = GetLastError();
FindClose(find_handle);
if (last_error != ERROR_NO_MORE_FILES) return MapError(last_error);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_File::GetRoots
+---------------------------------------------------------------------*/
NPT_Result
NPT_File::GetRoots(NPT_List<NPT_String>& roots)
{
roots.Clear();
#if defined(_WIN32_WCE) || defined(_XBOX)
return NPT_ERROR_NOT_IMPLEMENTED;
#else
DWORD drives = GetLogicalDrives();
for (unsigned int i=0; i<26; i++) {
if (drives & (1<<i)) {
char drive_name[4] = {'A'+i, ':', '\\', 0};
roots.Add(drive_name);
}
}
return NPT_SUCCESS;
#endif
}
/*----------------------------------------------------------------------
| NPT_File::ListDirectory
+---------------------------------------------------------------------*/
NPT_Result
NPT_File::ListDirectory(NPT_List<NPT_String>& entries)
{
entries.Clear();
return ListDirectory(m_Path.GetChars(), entries);
}