static void *resizeImage( const char *buf, int bufLen, int width, int height, MyData *myData, int *size )
{
char *ptr;
gdImagePtr dest, src;
if ( myData->IMAGE_TYPE == HTTP_IMG_JPEG )
src = gdImageCreateFromJpegPtr( bufLen, (void *)buf );
else if ( myData->IMAGE_TYPE == HTTP_IMG_GIF )
src = gdImageCreateFromGifPtr( bufLen, (void *)buf );
else if ( myData->IMAGE_TYPE == HTTP_IMG_PNG )
src = gdImageCreateFromPngPtr( bufLen, (void *)buf );
else
return NULL;
if ( !width && !height )
return NULL;
else if ( !width )
width = height * src->sx / src->sy;
else if ( !height )
height = width * src->sy / src->sx;
dest = gdImageCreateTrueColor( width, height );
gdImageCopyResampled( dest, src, 0, 0, 0, 0,
width, height,
src->sx, src->sy );
if ( myData->IMAGE_TYPE == HTTP_IMG_JPEG )
ptr = gdImageJpegPtr( dest, size, 50 );
else if ( myData->IMAGE_TYPE == HTTP_IMG_GIF )
ptr = gdImageGifPtr( dest, size );
else if ( myData->IMAGE_TYPE == HTTP_IMG_PNG )
ptr = gdImagePngPtr( dest, size );
return ptr;
}
unsigned char* convertToBase64(gdImagePtr im) {
// Convert the image to 1peg, default quality, getting
// back pointer to allocated bytes and length
int size;
void* jpegbytes = gdImageJpegPtr(im, &size, 75);
size_t encodedsize = 0;
unsigned char* source = (unsigned char*) jpegbytes;
unsigned char* b64codes = NULL;
// Invoke base64 encoder first time just to get length of
// base 64 string
base64_encode(b64codes, &encodedsize, source, size);
// Allocate space
b64codes = malloc(encodedsize + 1);
// Convert
int res = base64_encode(b64codes, &encodedsize, source, size);
gdFree(jpegbytes);
if (res != 0) {
printf("Failed to base 64 encode data\n");
if (b64codes != NULL)
free(b64codes);
return NULL;
}
return b64codes;
}
static int
szm_do_scale_jpg(char *in, int in_len, uint8_t scale, char **out, int *out_len)
{
gdImagePtr im_in, im_out;
int x, y, new_x, new_y;
im_in = gdImageCreateFromJpegPtr(in_len, in);
if (!im_in)
return -SZM_ERR_IMGFMT;
x = gdImageSX(im_in);
y = gdImageSY(im_in);
new_x = x / scale;
new_y = y / scale;
if (new_x == 0)
new_x = 1;
if (new_y == 0)
new_y = 1;
im_out = gdImageCreateTrueColor(new_x, new_y);
if (!im_out) {
gdImageDestroy(im_in);
return -SZM_ERR_IMGPROC;
}
gdImageCopyResized(im_out, im_in, 0, 0, 0, 0,
im_out->sx, im_out->sy, im_in->sx, im_in->sy);
*out = gdImageJpegPtr(im_out, out_len, -1);
gdImageDestroy(im_in);
gdImageDestroy(im_out);
return 0;
}
int ImageWrite( struct ImageLibrary *im, File *rootDev, gdImagePtr img, const char *path )
{
FHandler *fh = rootDev->f_FSys;
File *rfp = (File *)fh->FileOpen( rootDev, path, "wb" );
if( rfp != NULL )
{
char *buffer = NULL;
int length = 0;
int psize = strlen( path );
if( psize > 3 ) //we are checking if file have extension
{
char ext[ 4 ];
strcpy( ext, &(path[ psize-4 ]) );
ext[ 0 ] = toupper( ext[ 0 ] );
ext[ 1 ] = toupper( ext[ 1 ] );
ext[ 2 ] = toupper( ext[ 2 ] );
if( CHECK_EXT( ext, 'P','N','G' ) )
{
buffer = gdImagePngPtr( img, &length );
}else if( CHECK_EXT( ext, 'J','P','G' ) ){
buffer = gdImageJpegPtr( img, &length, 100 );
}else if( CHECK_EXT( ext, 'G','I','F' ) ){
buffer = gdImageGifPtr( img, &length );
}else if( CHECK_EXT( ext, 'W','E','B' ) ){
buffer = gdImageWebpPtr( img, &length );
}else if( CHECK_EXT( ext, 'I','I','F' ) ){
buffer = gdImageTiffPtr( img, &length );
}else if( CHECK_EXT( ext, 'B','M','P' ) ){
buffer = gdImageBmpPtr( img, &length, 100 );
}
if( buffer == NULL )
{
fh->FileClose( rootDev, rfp );
ERROR("Cannot save picture, GD couldnt create buffer from image\n");
return 2;
}
else
{
fh->FileWrite( rfp, buffer, length );
}
}
else
{
ERROR("Extension name is too short, file format not recognized\n");
}
fh->FileClose( rootDev, rfp );
}
else
{
ERROR("Cannot open file: %s to write\n", path );
return 1;
}
return 0;
}
static int
szm_do_box_bmp(char *in, int in_len, uint16_t boxsize, char **out, int *out_len)
{
int x, y;
int new_x, new_y;
gdImagePtr im_in, im_out;
im_in = gdImageCreateFromBmpPtr(in_len, in);
if (!im_in)
return -SZM_ERR_IMGFMT;
x = gdImageSX(im_in);
y = gdImageSY(im_in);
if (x == 0)
x = 1;
if (y == 0)
y = 1;
if (x <= boxsize && y <= boxsize) {
*out = gdImageJpegPtr(im_in, out_len, -1);
gdImageDestroy(im_in);
return 0;
}
if (x > y) {
new_y = boxsize * y / x;
new_x = boxsize;
} else {
new_x = x * boxsize / y;
new_y = boxsize;
}
if (new_x == 0)
new_x = 1;
if (new_y == 0)
new_y = 1;
im_out = gdImageCreateTrueColor(new_x, new_y);
if (!im_out) {
gdImageDestroy(im_in);
return -SZM_ERR_IMGPROC;
}
gdImageCopyResized(im_out, im_in, 0, 0, 0, 0,
im_out->sx, im_out->sy, im_in->sx, im_in->sy);
*out = gdImageJpegPtr(im_out, out_len, -1);
gdImageDestroy(im_in);
gdImageDestroy(im_out);
return 0;
return 0;
}
value ImageJpegData(value img, value quality) {
ImageData _img = getImage(img);
int _quality = val_int(quality);
int size;
void *ptr = gdImageJpegPtr(imageImage(_img),&size,_quality);
buffer ret = alloc_buffer(NULL);
buffer_append_sub(ret,ptr,size);
gdFree(ptr);
return buffer_to_string(ret);
}
static u_char *
ngx_http_image_out(ngx_http_request_t *r, ngx_uint_t type, gdImagePtr img,
int *size)
{
char *failed;
u_char *out;
ngx_int_t jq;
ngx_http_image_filter_conf_t *conf;
out = NULL;
switch (type) {
case NGX_HTTP_IMAGE_JPEG:
conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);
jq = ngx_http_image_filter_get_value(r, conf->jqcv, conf->jpeg_quality);
if (jq <= 0) {
return NULL;
}
out = gdImageJpegPtr(img, size, jq);
failed = "gdImageJpegPtr() failed";
break;
case NGX_HTTP_IMAGE_GIF:
out = gdImageGifPtr(img, size);
failed = "gdImageGifPtr() failed";
break;
case NGX_HTTP_IMAGE_PNG:
out = gdImagePngPtr(img, size);
failed = "gdImagePngPtr() failed";
break;
case NGX_HTTP_IMAGE_BMP:
out = gdImageBmpPtr(img, size, -1);
failed = "gdImageBmpPtr() failed";
break;
default:
failed = "unknown image type";
break;
}
if (out == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, failed);
}
return out;
}
static void thumb_to_string(void *conf)
{
ngx_image_conf_t *info = conf;
switch(info->dest_type)
{
case NGX_IMAGE_PNG:
info->img_data = gdImagePngPtr(info->dst_im,&info->img_size);
break;
case NGX_IMAGE_GIF:
info->img_data = gdImageGifPtr(info->dst_im,&info->img_size);
break;
case NGX_IMAGE_JPEG:
info->img_data = gdImageJpegPtr(info->dst_im,&info->img_size,info->jpeg_quality);
break;
}
gdImageDestroy(info->dst_im);
}
int main()
{
gdImagePtr im;
void *data;
int size, red;
im = gdImageCreate(100, 100);
gdImageSetResolution(im, 72, 300);
red = gdImageColorAllocate(im, 0xFF, 0x00, 0x00);
gdImageFilledRectangle(im, 0, 0, 99, 99, red);
data = gdImageJpegPtr(im, &size, 10);
gdImageDestroy(im);
im = gdImageCreateFromJpegPtr(size, data);
gdTestAssert(gdImageResolutionX(im) == 72);
gdTestAssert(gdImageResolutionY(im) == 300);
gdFree(data);
gdImageDestroy(im);
return 0;
}
void plD_eop_jpeg(PLStream *pls)
{
png_Dev *dev=(png_Dev *)pls->dev;
int im_size=0;
void *im_ptr=NULL;
if (pls->family || pls->page == 1) {
/* image is written to output file by the driver
since if the gd.dll is linked to a different c
lib a crash occurs - this fix works also in Linux */
/* gdImageJpeg(dev->im_out, pls->OutFile, pls->dev_compression); */
im_ptr = gdImageJpegPtr(dev->im_out, &im_size, pls->dev_compression);
if( im_ptr ) {
fwrite(im_ptr, sizeof(char), im_size, pls->OutFile);
gdFree(im_ptr);
}
gdImageDestroy(dev->im_out);
dev->im_out = NULL;
}
}
NEOERR* mimg_output(void *pic)
{
NEOERR *err;
MCS_NOT_NULLA(pic);
gdImagePtr im = (gdImagePtr)pic;
char *temps; int tempi;
err = cgiwrap_writef("Content-Type: image/jpeg\r\n\r\n");
if (err != STATUS_OK) return nerr_pass(err);
/*
* gdImageJpegCtx(data, gdoutctx, -1) core dump on fastcgi mode
*/
temps = (char*) gdImageJpegPtr(im, &tempi, -1);
cgiwrap_write(temps, tempi);
gdImageDestroy(im);
gdFree(temps);
return STATUS_OK;
}
int main()
{
gdImagePtr im;
void *data;
int size, red;
im = gdImageCreate(100, 100);
gdImageSetResolution(im, 72, 300);
red = gdImageColorAllocate(im, 0xFF, 0x00, 0x00);
gdImageFilledRectangle(im, 0, 0, 99, 99, red);
data = gdImageJpegPtr(im, &size, 10);
gdImageDestroy(im);
im = gdImageCreateFromJpegPtr(size, data);
gdFree(data);
if (!gdTestAssert(gdImageResolutionX(im) == 72) || !gdTestAssert(gdImageResolutionY(im) == 300)) {
gdTestErrorMsg("failed image resolution X (%d != 72) or Y (%d != 300)\n", gdImageResolutionX(im), gdImageResolutionY(im));
gdImageDestroy(im);
return 1;
}
gdImageDestroy(im);
return 0;
}
static u_char *ngx_http_small_light_gd_out(gdImagePtr img, ngx_int_t type, int *size, double q)
{
u_char *out = NULL;
switch (type) {
case NGX_HTTP_SMALL_LIGHT_IMAGE_JPEG:
out = gdImageJpegPtr(img, size, (int)q);
break;
case NGX_HTTP_SMALL_LIGHT_IMAGE_GIF:
out = gdImageGifPtr(img, size);
break;
case NGX_HTTP_SMALL_LIGHT_IMAGE_PNG:
out = gdImagePngPtr(img, size);
break;
case NGX_HTTP_SMALL_LIGHT_IMAGE_WEBP:
#ifdef NGX_HTTP_SMALL_LIGHT_GD_WEBP_ENABLED
out = gdImageWebpPtrEx(img, size, (int)q);
#endif
break;
default:
break;
}
return out;
}
static int
szm_do_scale_head_photo_internal(gdImagePtr im_in, char **out, int *out_len, int in_len)
{
gdImagePtr im_out;
int x, y, y_offset=0, y_n, new_x, new_y, resize=0;
x = gdImageSX(im_in);
y = gdImageSY(im_in);
if ( x <0 ||y<0 ||x > MAX_PHOTO_SCALE || y > MAX_PHOTO_SCALE){
gdImageDestroy(im_in);
return -SZM_ERR_TOOLARGE;
}
if (x <= HEAD_PHOTO_WEIGHT && y <= HEAD_PHOTO_HEIGHT){
new_x = x;
new_y = y;
if(in_len <= HEAD_PHOTO_SIZE){
gdImageDestroy(im_in);
return -SZM_ERR_NONEED;
}
} else if ( x <= HEAD_PHOTO_WEIGHT){
new_x = x;
new_y = HEAD_PHOTO_HEIGHT;
y_offset = (y - HEAD_PHOTO_HEIGHT) / 2;
} else {
resize = 1;
new_x = HEAD_PHOTO_WEIGHT;
y_n = HEAD_PHOTO_HEIGHT * x / HEAD_PHOTO_WEIGHT;
if(y_n >= y){
y_n = y;
new_y = HEAD_PHOTO_WEIGHT * y / x;
if(!new_y)
new_y=1;
} else {
y_offset = (y - y_n) / 2;
new_y = HEAD_PHOTO_HEIGHT;
}
}
im_out = gdImageCreateTrueColor(new_x, new_y);
if (!im_out) {
gdImageDestroy(im_in);
return -SZM_ERR_IMGPROC;
}
if(resize)
gdImageCopyResampled(im_out, im_in, 0, 0, 0, y_offset,
im_out->sx, im_out->sy, im_in->sx, y_n);
else
gdImageCopy(im_out, im_in, 0, 0, 0, y_offset, im_out->sx, im_out->sy);
*out = gdImageGifPtr(im_out, out_len);
if(*out_len>HEAD_PHOTO_SIZE){
x=1;
y=100;
while(x+1<y){
gdFree(*out);
*out = gdImageJpegPtr(im_out, out_len, (x+y)/2);
if(*out_len>HEAD_PHOTO_SIZE)
y=(x+y)/2;
else
x=(x+y)/2;
}
}
gdImageDestroy(im_in);
gdImageDestroy(im_out);
return 0;
}
result_t Image::getData(int32_t format, int32_t quality,
obj_ptr<Buffer_base> &retVal, AsyncEvent *ac)
{
if (!m_image)
return CHECK_ERROR(CALL_E_INVALID_CALL);
if (!ac)
return CHECK_ERROR(CALL_E_NOSYNC);
int32_t size = 0;
void *data = NULL;
int32_t sx = gdImageSX(m_image);
int32_t sy = gdImageSY(m_image);
int32_t i, j;
int32_t trans = -1;
if (gdImageTrueColor(m_image))
{
for (i = 0; i < sx && trans == -1; i ++)
for (j = 0; j < sy && trans == -1; j++)
if ((gdImageGetPixel(m_image, i, j) & 0xff000000) != 0)
trans = 0;
}
else
trans = gdImageGetTransparent(m_image);
gdImagePtr nowImage = m_image;
if (trans != -1)
{
if (format != gd_base::_PNG)
{
if (gdImageTrueColor(m_image))
nowImage = gdImageCreateTrueColor(sx, sy);
else
{
nowImage = gdImageCreate(sx, sy);
gdImagePaletteCopy(nowImage, m_image);
}
gdImageFilledRectangle(nowImage, 0, 0, sx, sy, gdImageColorAllocate(nowImage, 255, 255, 255));
gdImageCopy(nowImage, m_image, 0, 0, 0, 0, sx, sy);
}
else if (gdImageTrueColor(m_image))
gdImageSaveAlpha(m_image, 1);
}
switch (format)
{
case gd_base::_GIF:
data = gdImageGifPtr(nowImage, &size);
break;
case gd_base::_PNG:
data = gdImagePngPtr(nowImage, &size);
break;
case gd_base::_JPEG:
{
unsigned char *ed_data = NULL;
uint32_t ed_size = 0;
data = gdImageJpegPtr(nowImage, &size, quality, ed_data, ed_size);
if (ed_data)
free(ed_data);
break;
}
case gd_base::_TIFF:
data = gdImageTiffPtr(nowImage, &size);
break;
case gd_base::_BMP:
data = gdImageBmpPtr(nowImage, &size, 1);
break;
case gd_base::_WEBP:
data = gdImageWebpPtrEx(nowImage, &size, quality);
break;
}
if (nowImage != m_image)
gdImageDestroy(nowImage);
if (data == NULL)
return CHECK_ERROR(CALL_E_INVALIDARG);
retVal = new Buffer(std::string((char *) data, size));
gdFree(data);
return 0;
}
int msasShowAdminLogon(int confd,ltMsgHead *ltMsgPk,lt_shmHead *lt_MMHead){
ltDbHeadPtr dbPtr;
unsigned int sid;
char sIp[24];
int i;
char strsid[12];
int adminipcount;
int ipok;
char sqlBuf[1024];
ltDbCursor *tempCursor;
LT_DBROW tempRow;
sid=0;
memset(sIp,0,sizeof(sIp));
ltMsgGetSomeNVar(ltMsgPk,1,"clientip", LT_TYPE_STRING, 19, sIp);
dbPtr=lt_dbinit();
lt_db_htmlpage(dbPtr,"utf-8");
adminipcount=0;
ipok=0;
sprintf(sqlBuf,"select count(*) from msasAdminArea ");
tempCursor=ltDbOpenCursor(G_DbCon,sqlBuf);
if(tempCursor!=NULL){
tempRow= ltDbFetchRow(tempCursor);
if(tempRow!=NULL){
adminipcount=atol(tempRow[0]);
}
ltDbCloseCursor(tempCursor);
}
if(adminipcount==0){
ipok=1;
}else{
unsigned int s_ip,e_ip,my_ip;
my_ip=ntohl(inet_addr(sIp));
sprintf(sqlBuf,"select ipstart,ipend from msasAdminArea ");
tempCursor=ltDbOpenCursor(G_DbCon,sqlBuf);
if(tempCursor!=NULL){
tempRow= ltDbFetchRow(tempCursor);
while(tempRow!=NULL){
s_ip=ntohl(inet_addr(tempRow[0]));
e_ip=ntohl(inet_addr(tempRow[1]));
if( (my_ip >=s_ip) && (my_ip <=e_ip) ){
ipok=1;
break;
}
}
ltDbCloseCursor(tempCursor);
}
}
if(ipok==0){
ltMsgPk->msgpktype=1;
lt_TcpResponse(confd,ltMsgPk,2,"lthead",LT_TYPE_STRING,"Content-type: text/html; charset=utf-8\n","lthtml",LT_TYPE_STRING,"<html><body bgcolor=\"#cccccc\">Ip Area error!</body></html>");
ltMsgFree(ltMsgPk);
return 0;
}
for(i=0;i<MAX_ADMIN_SESSION;i++){
if(strcmp(_ltPubInfo->admSession[i].lright,"0000000000000000000000000000000000000000000")==0){
if( (time(0)-_ltPubInfo->admSession[i].lasttime) > MAX_ADMIN_TRYTIMEOUT ){
_ltPubInfo->admSession[i].lSip=0;
_ltPubInfo->admSession[i].lasttime=0;
_ltPubInfo->admSession[i].trytimes=0;
_ltPubInfo->admSession[i].lSid=0;
sprintf(_ltPubInfo->admSession[i].lright,"%s","0000000000000000000000000000000000000000000");
}
}else{
if( (time(0)-_ltPubInfo->admSession[i].lasttime) > MAX_ADMIN_TIMEOUT ){
_ltPubInfo->admSession[i].lSip=0;
_ltPubInfo->admSession[i].lasttime=0;
_ltPubInfo->admSession[i].trytimes=0;
_ltPubInfo->admSession[i].lSid=0;
sprintf(_ltPubInfo->admSession[i].lright,"%s","0000000000000000000000000000000000000000000");
}
}
}
for(i=0;i<MAX_ADMIN_SESSION;i++){
if(_ltPubInfo->admSession[i].lSip==ntohl(inet_addr(sIp)) ){
_ltPubInfo->admSession[i].lSip=0;
_ltPubInfo->admSession[i].lasttime=0;
_ltPubInfo->admSession[i].trytimes=0;
_ltPubInfo->admSession[i].lSid=0;
sprintf(_ltPubInfo->admSession[i].lright,"%s","0000000000000000000000000000000000000000000");
}
}
{
gdImagePtr im;
int white,red;
char caTempDir[128];
char caTempFile[128];
void *pJpg;
int lSize;
sid=time(0)%10000;
sprintf(strsid,"%04d",sid);
im = gdImageCreate(40,16);
red= gdImageColorAllocate(im, 0, 0, 0);
white= gdImageColorAllocate(im, 255, 255, 255);
gdImageRectangle(im, 0, 0, 40, 16, red);
gdImageString(im, gdFontMediumBold, 5, 2, strsid, white);
sprintf(caTempDir,"%s/%lu/",_TMPDIR,ltStrGetId());
if(ltFileIsExist(caTempDir)!=1) {
if(mkdir(caTempDir,S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)!=0) {
return 0;
}
}
sprintf(caTempFile,"%scheck.jpg",caTempDir);
pJpg = gdImageJpegPtr( im,&lSize,-1);
gdImageDestroy(im);
saveJPG(pJpg,lSize, caTempFile);
lt_db_setcookie(dbPtr,"strsid", strsid);
lt_dbput_rootvars(dbPtr,1,"file1",caTempFile+strlen(_TMPDIR)+1);
ltMsgPk->msgpktype=1;
lt_dbput_html(confd,ltMsgPk,dbPtr->doc,"/app/msa/msas/htmlplt/index.htm",dbPtr->head,0);
}
ltMsgFree(ltMsgPk);
lt_dbfree(dbPtr);
return 0;
}
