int main (int argc, char *argv[]) { int fd; unsigned char argp[1024]; int length; --argc; ++argv; if (argc != 1) error(1, "usage: usb_printerid /dev/usb/lp0\n"); fd = open(argv[0], O_RDWR); if (fd < 0) error(1, "can't open '%s'\n", argv[0]); if (ioctl(fd, LPIOC_GET_DEVICE_ID(sizeof(argp)), argp) < 0) error(1, "GET_DEVICE_ID on '%s'\n", argv[0]); length = (argp[0] << 8) + argp[1] - 2; printf("GET_DEVICE_ID string:\n"); fwrite(argp + 2, 1, length, stdout); printf("\n"); #if 0 if (ioctl(fd, LPGETSTATUS, &status) < 0) error(1, "LPGETSTATUS on '%s'\n", argv[0]); printf("Status: 0x%02x\n", status); #endif close(fd); exit(0); }
int /* O - 0 on success, -1 on failure */ backendGetDeviceID( int fd, /* I - File descriptor */ char *device_id, /* O - 1284 device ID */ int device_id_size, /* I - Size of buffer */ char *make_model, /* O - Make/model */ int make_model_size, /* I - Size of buffer */ const char *scheme, /* I - URI scheme */ char *uri, /* O - Device URI */ int uri_size) /* I - Size of buffer */ { #ifdef __APPLE__ /* This function is a no-op */ (void)fd; (void)device_id; (void)device_id_size; (void)make_model; (void)make_model_size; (void)scheme; (void)uri; (void)uri_size; return (-1); #else /* Get the device ID from the specified file descriptor... */ # ifdef __linux int length; /* Length of device ID info */ int got_id = 0; # endif /* __linux */ # if defined(__sun) && defined(ECPPIOC_GETDEVID) struct ecpp_device_id did; /* Device ID buffer */ # endif /* __sun && ECPPIOC_GETDEVID */ char *ptr; /* Pointer into device ID */ DEBUG_printf(("backendGetDeviceID(fd=%d, device_id=%p, device_id_size=%d, " "make_model=%p, make_model_size=%d, scheme=\"%s\", " "uri=%p, uri_size=%d)\n", fd, device_id, device_id_size, make_model, make_model_size, scheme ? scheme : "(null)", uri, uri_size)); /* * Range check input... */ if (!device_id || device_id_size < 32) { DEBUG_puts("backendGetDeviceID: Bad args!"); return (-1); } if (make_model) *make_model = '\0'; if (fd >= 0) { /* * Get the device ID string... */ *device_id = '\0'; # ifdef __linux if (ioctl(fd, LPIOC_GET_DEVICE_ID(device_id_size), device_id)) { /* * Linux has to implement things differently for every device it seems. * Since the standard parallel port driver does not provide a simple * ioctl() to get the 1284 device ID, we have to open the "raw" parallel * device corresponding to this port and do some negotiation trickery * to get the current device ID. */ if (uri && !strncmp(uri, "parallel:/dev/", 14)) { char devparport[16]; /* /dev/parportN */ int devparportfd, /* File descriptor for raw device */ mode; /* Port mode */ /* * Since the Linux parallel backend only supports 4 parallel port * devices, just grab the trailing digit and use it to construct a * /dev/parportN filename... */ snprintf(devparport, sizeof(devparport), "/dev/parport%s", uri + strlen(uri) - 1); if ((devparportfd = open(devparport, O_RDWR | O_NOCTTY)) != -1) { /* * Claim the device... */ if (!ioctl(devparportfd, PPCLAIM)) { fcntl(devparportfd, F_SETFL, fcntl(devparportfd, F_GETFL) | O_NONBLOCK); mode = IEEE1284_MODE_COMPAT; if (!ioctl(devparportfd, PPNEGOT, &mode)) { /* * Put the device into Device ID mode... */ mode = IEEE1284_MODE_NIBBLE | IEEE1284_DEVICEID; if (!ioctl(devparportfd, PPNEGOT, &mode)) { /* * Read the 1284 device ID... */ if ((length = read(devparportfd, device_id, (size_t)device_id_size - 1)) >= 2) { device_id[length] = '\0'; got_id = 1; } } } /* * Release the device... */ ioctl(devparportfd, PPRELEASE); } close(devparportfd); } } } else got_id = 1; if (got_id) { /* * Extract the length of the device ID string from the first two * bytes. The 1284 spec says the length is stored MSB first... */ length = (int)((((unsigned)device_id[0] & 255) << 8) + ((unsigned)device_id[1] & 255)); /* * Check to see if the length is larger than our buffer; first * assume that the vendor incorrectly implemented the 1284 spec, * and then limit the length to the size of our buffer... */ if (length > device_id_size || length < 14) length = (int)((((unsigned)device_id[1] & 255) << 8) + ((unsigned)device_id[0] & 255)); if (length > device_id_size) length = device_id_size; /* * The length field counts the number of bytes in the string * including the length field itself (2 bytes). The minimum * length for a valid/usable device ID is 14 bytes: * * <LENGTH> MFG: <MFG> ;MDL: <MDL> ; * 2 + 4 + 1 + 5 + 1 + 1 */ if (length < 14) { /* * Can't use this device ID, so don't try to copy it... */ device_id[0] = '\0'; got_id = 0; } else { /* * Copy the device ID text to the beginning of the buffer and * nul-terminate. */ length -= 2; memmove(device_id, device_id + 2, (size_t)length); device_id[length] = '\0'; } } else { DEBUG_printf(("backendGetDeviceID: ioctl failed - %s\n", strerror(errno))); *device_id = '\0'; } # endif /* __linux */ # if defined(__sun) && defined(ECPPIOC_GETDEVID) did.mode = ECPP_CENTRONICS; did.len = device_id_size - 1; did.rlen = 0; did.addr = device_id; if (!ioctl(fd, ECPPIOC_GETDEVID, &did)) { /* * Nul-terminate the device ID text. */ if (did.rlen < (device_id_size - 1)) device_id[did.rlen] = '\0'; else device_id[device_id_size - 1] = '\0'; } # ifdef DEBUG else DEBUG_printf(("backendGetDeviceID: ioctl failed - %s\n", strerror(errno))); # endif /* DEBUG */ # endif /* __sun && ECPPIOC_GETDEVID */ } /* * Check whether device ID is valid. Turn line breaks and tabs to spaces and * reject device IDs with non-printable characters. */ for (ptr = device_id; *ptr; ptr ++) if (_cups_isspace(*ptr)) *ptr = ' '; else if ((*ptr & 255) < ' ' || *ptr == 127) { DEBUG_printf(("backendGetDeviceID: Bad device_id character %d.", *ptr & 255)); *device_id = '\0'; break; } DEBUG_printf(("backendGetDeviceID: device_id=\"%s\"\n", device_id)); if (scheme && uri) *uri = '\0'; if (!*device_id) return (-1); /* * Get the make and model... */ if (make_model) backendGetMakeModel(device_id, make_model, (size_t)make_model_size); /* * Then generate a device URI... */ if (scheme && uri && uri_size > 32) { int num_values; /* Number of keys and values */ cups_option_t *values; /* Keys and values in device ID */ const char *mfg, /* Manufacturer */ *mdl, /* Model */ *sern; /* Serial number */ char temp[256], /* Temporary manufacturer string */ *tempptr; /* Pointer into temp string */ /* * Get the make, model, and serial numbers... */ num_values = _cupsGet1284Values(device_id, &values); if ((sern = cupsGetOption("SERIALNUMBER", num_values, values)) == NULL) if ((sern = cupsGetOption("SERN", num_values, values)) == NULL) sern = cupsGetOption("SN", num_values, values); if ((mfg = cupsGetOption("MANUFACTURER", num_values, values)) == NULL) mfg = cupsGetOption("MFG", num_values, values); if ((mdl = cupsGetOption("MODEL", num_values, values)) == NULL) mdl = cupsGetOption("MDL", num_values, values); if (mfg) { if (!_cups_strcasecmp(mfg, "Hewlett-Packard")) mfg = "HP"; else if (!_cups_strcasecmp(mfg, "Lexmark International")) mfg = "Lexmark"; } else { strlcpy(temp, make_model, sizeof(temp)); if ((tempptr = strchr(temp, ' ')) != NULL) *tempptr = '\0'; mfg = temp; } if (!mdl) mdl = ""; if (!_cups_strncasecmp(mdl, mfg, strlen(mfg))) { mdl += strlen(mfg); while (isspace(*mdl & 255)) mdl ++; } /* * Generate the device URI from the manufacturer, make_model, and * serial number strings. */ httpAssembleURIf(HTTP_URI_CODING_ALL, uri, uri_size, scheme, NULL, mfg, 0, "/%s%s%s", mdl, sern ? "?serial=" : "", sern ? sern : ""); cupsFreeOptions(num_values, values); } return (0); #endif /* __APPLE__ */ }
void print(stk::rectangle rect, const unsigned char* raster_data) { IjsClientCtx* ctx; int job_id=1; char buf[2048]; int output_fd=open("/dev/usb/lp0", O_RDWR); std::string iee_device_id; // Will hold the device id int res=ioctl (output_fd, LPIOC_GET_DEVICE_ID(2048), buf); if(res==0) { // Could get Device ID short len; len = (unsigned)buf[0] << 8 | (unsigned)buf[1]; if(len>2048) len=2048; char* device_id=buf+2; device_id[len]=0; iee_device_id=std::string((const char*)device_id); } // Parsing printer Device ID int mfg_begin=iee_device_id.find("MFG:"); int mfg_end=iee_device_id.find(";",mfg_begin); std::string mfg=iee_device_id.substr(mfg_begin+4,mfg_end-mfg_begin-4); int mdl_begin=iee_device_id.find("MDL:"); int mdl_end=iee_device_id.find(";",mdl_begin); std::string mdl=iee_device_id.substr(mdl_begin+4,mdl_end-mdl_begin-4); std::cout << "Printer's Manufacturer is " << mfg << " Modell is " << mdl << std::endl; ctx = ijs_invoke_server ("hpijs"); ijs_client_open (ctx); ijs_client_begin_job (ctx, job_id); std::string str_output_fd=boost::lexical_cast<std::string>(output_fd); int err = ijs_client_set_param (ctx, job_id, "OutputFD", str_output_fd.c_str(), str_output_fd.size()); if(err<0) std::cerr << "didnt set parameter, err = " << err << std::endl; err = ijs_client_set_param (ctx, job_id, "DeviceManufacturer", mfg.c_str(), mfg.size()); if(err<0) std::cerr << "Couldnt set DeviceManufacturer, err = " << err << std::endl; err = ijs_client_set_param (ctx, job_id, "DeviceModel", mdl.c_str(), mdl.size()); if(err<0) std::cerr << "Couldnt set devicemodel, err = " << err << std::endl; set_parameter(ctx, job_id, "PaperSize","8.27x11.69"); //A4 //set_parameter(ctx, job_id, "PaperSize","3x3"); get_parameter(ctx, job_id, "PrintableArea"); set_parameter(ctx, job_id, "Height",boost::lexical_cast<std::string>(rect.height())); set_parameter(ctx, job_id, "Width",boost::lexical_cast<std::string>(rect.width())); set_parameter(ctx, job_id, "Dpi","300x300"); set_parameter(ctx, job_id, "BitsPerSample","8"); set_parameter(ctx, job_id, "NumChan","3"); set_parameter(ctx, job_id, "ColorSpace","DeviceRGB"); // unsigned char data[128*128*3]; // memset(data,0xff,sizeof(data)); err = ijs_client_begin_page (ctx, job_id); std::cerr << "begin page err = " << err << std::endl; err = ijs_client_send_data_wait (ctx, job_id, (const char*)raster_data, rect.width()*rect.height()*3); if(err!=0) std::cerr << "Data send, err is " << err << std::endl; /* for(int i=0;i<128;i++) { unsigned char* row=data+i*128*3; row[i*3+0]=0; row[i*3+1]=0; row[i*3+2]=0; row[i*3+(i%3)]=0xff; err = ijs_client_send_data_wait (ctx, job_id, (const char*)row, 128*3); if(err!=0) std::cerr << "Data send, err is " << err << std::endl; }*/ err = ijs_client_end_page (ctx, job_id); err = ijs_client_list_params (ctx, job_id, buf, 1024); if(err<0) std::cerr << "didnt get parameter list, err = " << err << std::endl; else { buf[err]=0; std::cerr << "Parameter list is " << buf << std::endl; } get_parameter(ctx, job_id, "Quality:Quality"); get_parameter(ctx, job_id, "Quality:ColorMode"); enum_parameter(ctx, job_id, "Dpi"); sleep(2); ijs_client_end_job (ctx, job_id); ijs_client_close (ctx); }