list_ports_linux.cc

Go to the documentation of this file.

#if defined(__linux__)

/*
 * Copyright (c) 2014 Craig Lilley <cralilley@gmail.com>
 * This software is made available under the terms of the MIT licence.
 * A copy of the licence can be obtained from:
 * http://opensource.org/licenses/MIT
 */

#include <vector>
#include <string>
#include <sstream>
#include <stdexcept>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cstdarg>
#include <cstdlib>

#include <glob.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include "serial/serial.h"

using serial::PortInfo;
using std::istringstream;
using std::ifstream;
using std::getline;
using std::vector;
using std::string;
using std::cout;
using std::endl;

static vector<string> glob(const vector<string>& patterns);
static string basename(const string& path);
static string dirname(const string& path);
static bool path_exists(const string& path);
static string realpath(const string& path);
static string usb_sysfs_friendly_name(const string& sys_usb_path);
static vector<string> get_sysfs_info(const string& device_path);
static string read_line(const string& file);
static string usb_sysfs_hw_string(const string& sysfs_path);
static string format(const char* format, ...);

vector<string>
glob(const vector<string>& patterns)
{
        vector<string> paths_found;

        if (patterns.size() == 0)
                return paths_found;

        glob_t glob_results;

        int glob_retval = glob(patterns[0].c_str(), 0, NULL, &glob_results);

        vector<string>::const_iterator iter = patterns.begin();

        while (++iter != patterns.end())
        {
                glob_retval = glob(iter->c_str(), GLOB_APPEND, NULL, &glob_results);
        }

        for (int path_index = 0; path_index < glob_results.gl_pathc; path_index++)
        {
                paths_found.push_back(glob_results.gl_pathv[path_index]);
        }

        globfree(&glob_results);

        return paths_found;
}

string
basename(const string& path)
{
        size_t pos = path.rfind("/");

        if (pos == std::string::npos)
                return path;

        return string(path, pos + 1, string::npos);
}

string
dirname(const string& path)
{
        size_t pos = path.rfind("/");

        if (pos == std::string::npos)
                return path;
        else if (pos == 0)
                return "/";

        return string(path, 0, pos);
}

bool
path_exists(const string& path)
{
        struct stat sb;

        if (stat(path.c_str(), &sb) == 0)
                return true;

        return false;
}

string
realpath(const string& path)
{
        char* real_path = realpath(path.c_str(), NULL);

        string result;

        if (real_path != NULL)
        {
                result = real_path;

                free(real_path);
        }

        return result;
}

string
usb_sysfs_friendly_name(const string& sys_usb_path)
{
        unsigned int device_number = 0;

        istringstream(read_line(sys_usb_path + "/devnum")) >> device_number;

        string manufacturer = read_line(sys_usb_path + "/manufacturer");

        string product = read_line(sys_usb_path + "/product");

        string serial = read_line(sys_usb_path + "/serial");

        if (manufacturer.empty() && product.empty() && serial.empty())
                return "";

        return format("%s %s %s", manufacturer.c_str(), product.c_str(), serial.c_str());
}

vector<string>
get_sysfs_info(const string& device_path)
{
        string device_name = basename(device_path);

        string friendly_name;

        string hardware_id;

        string sys_device_path = format("/sys/class/tty/%s/device", device_name.c_str());

        if (device_name.compare(0, 6, "ttyUSB") == 0)
        {
                sys_device_path = dirname(dirname(realpath(sys_device_path)));

                if (path_exists(sys_device_path))
                {
                        friendly_name = usb_sysfs_friendly_name(sys_device_path);

                        hardware_id = usb_sysfs_hw_string(sys_device_path);
                }
        }
        else if (device_name.compare(0, 6, "ttyACM") == 0)
        {
                sys_device_path = dirname(realpath(sys_device_path));

                if (path_exists(sys_device_path))
                {
                        friendly_name = usb_sysfs_friendly_name(sys_device_path);

                        hardware_id = usb_sysfs_hw_string(sys_device_path);
                }
        }
        else
        {
                // Try to read ID string of PCI device

                string sys_id_path = sys_device_path + "/id";

                if (path_exists(sys_id_path))
                        hardware_id = read_line(sys_id_path);
        }

        if (friendly_name.empty())
                friendly_name = device_name;

        if (hardware_id.empty())
                hardware_id = "n/a";

        vector<string> result;
        result.push_back(friendly_name);
        result.push_back(hardware_id);

        return result;
}

string
read_line(const string& file)
{
        ifstream ifs(file.c_str(), ifstream::in);

        string line;

        if (ifs)
        {
                getline(ifs, line);
        }

        return line;
}

string
format(const char* format, ...)
{
        va_list ap;

        size_t buffer_size_bytes = 256;

        string result;

        char* buffer = (char*)malloc(buffer_size_bytes);

        if (buffer == NULL)
                return result;

        bool done = false;

        unsigned int loop_count = 0;

        while (!done)
        {
                va_start(ap, format);

                int return_value = vsnprintf(buffer, buffer_size_bytes, format, ap);

                if (return_value < 0)
                {
                        done = true;
                }
                else if (return_value >= buffer_size_bytes)
                {
                        // Realloc and try again.

                        buffer_size_bytes = return_value + 1;

                        char* new_buffer_ptr = (char*)realloc(buffer, buffer_size_bytes);

                        if (new_buffer_ptr == NULL)
                        {
                                done = true;
                        }
                        else
                        {
                                buffer = new_buffer_ptr;
                        }
                }
                else
                {
                        result = buffer;
                        done = true;
                }

                va_end(ap);

                if (++loop_count > 5)
                        done = true;
        }

        free(buffer);

        return result;
}

string
usb_sysfs_hw_string(const string& sysfs_path)
{
        string serial_number = read_line(sysfs_path + "/serial");

        if (serial_number.length() > 0)
        {
                serial_number = format("SNR=%s", serial_number.c_str());
        }

        string vid = read_line(sysfs_path + "/idVendor");

        string pid = read_line(sysfs_path + "/idProduct");

        return format("USB VID:PID=%s:%s %s", vid.c_str(), pid.c_str(), serial_number.c_str());
}

vector<PortInfo>
serial::list_ports()
{
        vector<PortInfo> results;

        vector<string> search_globs;
        search_globs.push_back("/dev/ttyACM*");
        search_globs.push_back("/dev/ttyS*");
        search_globs.push_back("/dev/ttyUSB*");
        search_globs.push_back("/dev/tty.*");
        search_globs.push_back("/dev/cu.*");

        vector<string> devices_found = glob(search_globs);

        vector<string>::iterator iter = devices_found.begin();

        while (iter != devices_found.end())
        {
                string device = *iter++;

                vector<string> sysfs_info = get_sysfs_info(device);

                string friendly_name = sysfs_info[0];

                string hardware_id = sysfs_info[1];

                PortInfo device_entry;
                device_entry.port = device;
                device_entry.description = friendly_name;
                device_entry.hardware_id = hardware_id;

                results.push_back(device_entry);

        }

        return results;
}

#endif // defined(__linux__)